From 62315eec912274eb5e6f7b38958f34dfbe60d4f3 Mon Sep 17 00:00:00 2001 From: Vladimir Kutuev Date: Mon, 19 May 2025 18:02:40 +0300 Subject: [PATCH 1/8] gh-233: update opencl-headers dependency --- deps/opencl-headers/.clang-format | 123 + .../.github/workflows/linux.yml | 202 - .../.github/workflows/macos.yml | 53 - .../.github/workflows/presubmit.yml | 651 +++ .../.github/workflows/release.yml | 71 + .../.github/workflows/windows.yml | 247 - deps/opencl-headers/.gitignore | 14 + deps/opencl-headers/CL/cl.h | 23 +- deps/opencl-headers/CL/cl_d3d10.h | 262 +- deps/opencl-headers/CL/cl_d3d11.h | 262 +- deps/opencl-headers/CL/cl_dx9_media_sharing.h | 438 +- deps/opencl-headers/CL/cl_egl.h | 199 +- deps/opencl-headers/CL/cl_ext.h | 5095 +++++++++++------ deps/opencl-headers/CL/cl_function_types.h | 1184 ++++ deps/opencl-headers/CL/cl_gl.h | 469 +- deps/opencl-headers/CL/cl_gl_ext.h | 2 +- deps/opencl-headers/CL/cl_icd.h | 1459 +---- deps/opencl-headers/CL/cl_layer.h | 128 +- deps/opencl-headers/CL/cl_platform.h | 10 +- .../CL/cl_va_api_media_sharing_intel.h | 203 +- deps/opencl-headers/CMakeLists.txt | 60 +- deps/opencl-headers/OpenCL-Headers.pc.in | 7 + deps/opencl-headers/README.md | 50 + deps/opencl-headers/cmake/DebSourcePkg.cmake | 125 + deps/opencl-headers/cmake/JoinPaths.cmake | 26 + deps/opencl-headers/cmake/Package.cmake | 47 + deps/opencl-headers/cmake/PackageSetup.cmake | 56 + deps/opencl-headers/scripts/.gitignore | 1 + deps/opencl-headers/scripts/README.md | 38 + deps/opencl-headers/scripts/check-format.sh | 55 + deps/opencl-headers/scripts/cl_ext.h.mako | 447 ++ .../scripts/cl_function_types.h.mako | 62 + deps/opencl-headers/scripts/gen/__init__.py | 210 + deps/opencl-headers/scripts/gen_headers.py | 240 + deps/opencl-headers/scripts/requirements.txt | 1 + deps/opencl-headers/tests/CMakeLists.txt | 14 + .../tests/lang_c/CMakeLists.txt | 1 + .../tests/lang_cpp/CMakeLists.txt | 2 +- .../tests/pkgconfig/bare/CMakeLists.txt | 9 +- .../tests/pkgconfig/pkgconfig.c | 5 +- .../tests/pkgconfig/sdk/CMakeLists.txt | 9 +- deps/opencl-headers/tests/test_ext_headers.c | 56 + deps/opencl-headers/tests/test_headers.c | 32 +- 43 files changed, 8593 insertions(+), 4055 deletions(-) create mode 100644 deps/opencl-headers/.clang-format delete mode 100644 deps/opencl-headers/.github/workflows/linux.yml delete mode 100644 deps/opencl-headers/.github/workflows/macos.yml create mode 100644 deps/opencl-headers/.github/workflows/presubmit.yml create mode 100644 deps/opencl-headers/.github/workflows/release.yml delete mode 100644 deps/opencl-headers/.github/workflows/windows.yml create mode 100644 deps/opencl-headers/.gitignore create mode 100644 deps/opencl-headers/CL/cl_function_types.h create mode 100644 deps/opencl-headers/OpenCL-Headers.pc.in create mode 100644 deps/opencl-headers/cmake/DebSourcePkg.cmake create mode 100644 deps/opencl-headers/cmake/JoinPaths.cmake create mode 100644 deps/opencl-headers/cmake/Package.cmake create mode 100644 deps/opencl-headers/cmake/PackageSetup.cmake create mode 100644 deps/opencl-headers/scripts/.gitignore create mode 100644 deps/opencl-headers/scripts/README.md create mode 100755 deps/opencl-headers/scripts/check-format.sh create mode 100644 deps/opencl-headers/scripts/cl_ext.h.mako create mode 100644 deps/opencl-headers/scripts/cl_function_types.h.mako create mode 100644 deps/opencl-headers/scripts/gen/__init__.py create mode 100644 deps/opencl-headers/scripts/gen_headers.py create mode 100644 deps/opencl-headers/scripts/requirements.txt create mode 100644 deps/opencl-headers/tests/test_ext_headers.c diff --git a/deps/opencl-headers/.clang-format b/deps/opencl-headers/.clang-format new file mode 100644 index 000000000..d563a411a --- /dev/null +++ b/deps/opencl-headers/.clang-format @@ -0,0 +1,123 @@ +--- +Language: Cpp +AccessModifierOffset: -4 +AlignAfterOpenBracket: Align +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Right +AlignOperands: false +AlignTrailingComments: false +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: true +AllowShortFunctionsOnASingleLine: All +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: WithoutElse +AllowShortLoopsOnASingleLine: true +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: true + AfterEnum: true + AfterFunction: true + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: true + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: true + IndentBraces: false + SplitEmptyFunction: false + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: NonAssignment +BreakBeforeBraces: Custom +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeColon +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeColon +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: false +DerivePointerAlignment: true +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: false +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + - Regex: '.*' + Priority: 1 +IncludeIsMainRegex: '(Test)?$' +IndentCaseLabels: true +IndentPPDirectives: None +IndentWidth: 4 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 2 +NamespaceIndentation: Inner +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 4 +ObjCSpaceAfterProperty: true +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Left +ReflowComments: true +SortIncludes: false +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: true +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: false +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: ControlStatements +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp11 +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 4 +UseTab: Never diff --git a/deps/opencl-headers/.github/workflows/linux.yml b/deps/opencl-headers/.github/workflows/linux.yml deleted file mode 100644 index 1dfeebf59..000000000 --- a/deps/opencl-headers/.github/workflows/linux.yml +++ /dev/null @@ -1,202 +0,0 @@ -name: Linux - -on: [push, pull_request] - -jobs: - compatibility: - runs-on: ubuntu-18.04 - container: streamhpc/opencl-sdk-base:ubuntu-18.04-20220127 - strategy: - matrix: - # TODO: CMake 3.0.2 is Headers minimum (and ubuntu 18.04 canonical apt repo ver), not this repo's min - # Replace once backport to C++14 happened - include: - # Unix Makefiles - # One CMake version - # For all compilers - # For all configurations - # For all target architectures - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 64 - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 64 - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 32 - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 32 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 64 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 64 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 32 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 32 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 64 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 64 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 32 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 32 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 64 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 64 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Debug - BIN: 32 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.0.2 - GEN: Unix Makefiles - CONFIG: Release - BIN: 32 - # Multi-config generators - # One CMake version - # For all compilers - # For all architectures - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 64 - - C_COMPILER: gcc-7 - CXX_COMPILER: g++-7 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 32 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 64 - - C_COMPILER: gcc-11 - CXX_COMPILER: g++-11 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 32 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 64 - - C_COMPILER: clang-8 - CXX_COMPILER: clang++-8 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 32 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 64 - - C_COMPILER: clang-13 - CXX_COMPILER: clang++-13 - CMAKE: 3.22.1 - GEN: Ninja Multi-Config - BIN: 32 - env: - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - steps: - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - - - name: Configure - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - `if [[ "${{matrix.GEN}}" == "Unix Makefiles" ]]; then echo -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}}; fi;` - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -Werror -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.C_COMPILER}} - -D CMAKE_C_EXTENSIONS=OFF - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -Werror -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=${{matrix.CXX_COMPILER}} - -D CMAKE_CXX_EXTENSIONS=OFF - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -B$GITHUB_WORKSPACE/build - -H$GITHUB_WORKSPACE - - - name: Build - shell: bash - run: if [[ "${{matrix.GEN}}" == "Unix Makefiles" ]]; - then - $CMAKE_EXE --build $GITHUB_WORKSPACE/build -- -j`nproc`; - else - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug -- -j`nproc`; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release -- -j`nproc`; - fi; - - - name: Test - shell: bash - working-directory: ${{runner.workspace}}/OpenCL-Headers/build - run: if [[ "${{matrix.GEN}}" == "Unix Makefiles" ]]; - then - $CTEST_EXE --output-on-failure --parallel `nproc`; - else - $CTEST_EXE --output-on-failure -C Debug --parallel `nproc`; - $CTEST_EXE --output-on-failure -C Release --parallel `nproc`; - fi; \ No newline at end of file diff --git a/deps/opencl-headers/.github/workflows/macos.yml b/deps/opencl-headers/.github/workflows/macos.yml deleted file mode 100644 index eae6a5452..000000000 --- a/deps/opencl-headers/.github/workflows/macos.yml +++ /dev/null @@ -1,53 +0,0 @@ -name: MacOS - -on: [push, pull_request] - -jobs: - compatibility: - runs-on: macos-latest - strategy: - matrix: - VER: [9, 11] - GEN: [Xcode, Ninja Multi-Config] - STD: [11, 17] - - steps: - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - - - name: Create Build Environment - shell: bash - run: | - cmake -E make_directory $GITHUB_WORKSPACE/build; - cmake -E make_directory $GITHUB_WORKSPACE/install; - if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi; - # Install Ninja only if it's the selected generator and it's not available. - cmake --version - - - name: Configure CMake - shell: bash - run: cmake - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -Werror" - -D CMAKE_C_COMPILER=/usr/local/bin/gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=OFF - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -Werror" - -D CMAKE_CXX_COMPILER=/usr/local/bin/g++-${{matrix.VER}} - -D CMAKE_CXX_EXTENSIONS=OFF - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -S $GITHUB_WORKSPACE - -B $GITHUB_WORKSPACE/build - - - name: Build - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` `if [[ "${{matrix.GEN}}" == "Xcode" ]]; then echo "-- -quiet"; fi;` - cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` `if [[ "${{matrix.GEN}}" == "Xcode" ]]; then echo "-- -quiet"; fi;` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-Headers/build - shell: bash - run: | - ctest -C Release --output-on-failure --parallel `sysctl -n hw.logicalcpu` - ctest -C Debug --output-on-failure --parallel `sysctl -n hw.logicalcpu` \ No newline at end of file diff --git a/deps/opencl-headers/.github/workflows/presubmit.yml b/deps/opencl-headers/.github/workflows/presubmit.yml new file mode 100644 index 000000000..ea3594561 --- /dev/null +++ b/deps/opencl-headers/.github/workflows/presubmit.yml @@ -0,0 +1,651 @@ +name: Presubmit + +on: + push: + paths-ignore: + - '**/*.md' + pull_request: + paths-ignore: + - '**/*.md' + +jobs: + format: + name: Code formatting + runs-on: ubuntu-latest + defaults: + run: + shell: bash + steps: + - uses: actions/checkout@v4 + with: + # repository: ${{github.repository}} (default) + fetch-depth: 0 + - name: Install clang-format + run: sudo apt-get install clang-format + - name: Check format + run: $GITHUB_WORKSPACE/scripts/check-format.sh + origin/`if [[ "${{github.event_name}}" == "push" ]]; then echo "main"; else echo "${{github.base_ref}}"; fi` + --binary clang-format + + linux: + runs-on: ubuntu-latest + needs: format + defaults: + run: + shell: bash + strategy: + matrix: + CMAKE: [3.26.4] + COMPILER: + - C_NAME: gcc + CXX_NAME: g++ + VER: 11 + - C_NAME: gcc + CXX_NAME: g++ + VER: 13 + - C_NAME: clang + CXX_NAME: clang++ + VER: 14 + - C_NAME: clang + CXX_NAME: clang++ + VER: 16 + BIN: [64] + STD: [99, 11, 17] + CONF: + - GEN: Unix Makefiles + CONFIG: Debug + - GEN: Unix Makefiles + CONFIG: Release + - GEN: Ninja Multi-Config + CONFIG: Release + IMAGE: + - khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-22.04.20230717 + include: + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 64 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 64 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 32 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 32 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 11 + BIN: 64 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-22.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 11 + BIN: 64 + STD: 99 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-22.04.20230717 + container: ${{matrix.IMAGE}} + env: + CMAKE_EXE: /opt/Kitware/CMake/${{matrix.CMAKE}}/bin/cmake + CPACK_EXE: /opt/Kitware/CMake/${{matrix.CMAKE}}/bin/cpack + CTEST_EXE: /opt/Kitware/CMake/${{matrix.CMAKE}}/bin/ctest + CC: ${{matrix.COMPILER.C_NAME}}-${{matrix.COMPILER.VER}} + CXX: ${{matrix.COMPILER.CXX_NAME}}-${{matrix.COMPILER.VER}} + CFLAGS: -Wall -Wextra -pedantic -Werror -m${{matrix.BIN}} + + steps: + - name: Install system CMake + if: ${{matrix.CMAKE}} == 'system' + run: apt-get update -qq && apt-get install -y cmake && + echo "CMAKE_EXE=cmake" >> "$GITHUB_ENV" && + echo "CPACK_EXE=cpack" >> "$GITHUB_ENV" && + echo "CTEST_EXE=ctest" >> "$GITHUB_ENV" + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + + - name: Configure + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + -D BUILD_TESTING=ON + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_C_STANDARD=${{matrix.STD}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -D CPACK_PACKAGING_INSTALL_PREFIX=/usr + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release; + fi; + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-Headers/build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE --output-on-failure --no-tests=error -C Debug --parallel `nproc`; + $CTEST_EXE --output-on-failure --no-tests=error -C Release --parallel `nproc`; + fi; + + - name: Package DEB + run: $CPACK_EXE + --config "$GITHUB_WORKSPACE/build/CPackConfig.cmake" + -G DEB + -C Release + -B "$GITHUB_WORKSPACE/package-deb" + + - name: Consume (DEB) + run: dpkg -i $GITHUB_WORKSPACE/package-deb/*.deb && + $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_C_STANDARD=${{matrix.STD}} + -D CMAKE_C_EXTENSIONS=OFF + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_package && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Release; + fi + + - name: Run consume test (DEB) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-Headers/build_package + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (DEB) + run: | + # First check if OpenCL-Headers is locatable + pkg-config OpenCL-Headers --cflags + # /usr/include is already on the include search path, + # we expect no output + if [[ "$(pkg-config OpenCL-Headers --cflags)" ]]; + then + exit 1; + fi; + + - name: Uninstall (DEB) + run: apt-get remove -y opencl-c-headers + + - name: Test install + run: $CMAKE_EXE --build $GITHUB_WORKSPACE/build --target install --config ${{matrix.CONF.CONFIG}} --parallel `nproc` + + - name: Consume (install) + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_C_STANDARD=${{matrix.STD}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/install + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Release; + fi; + + - name: Run consume test (DEB) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-Headers/build_install + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (install) + run: PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/share/pkgconfig + pkg-config OpenCL-Headers --cflags | grep -q "\-I$GITHUB_WORKSPACE/install/include" + + windows: + runs-on: windows-latest + needs: format + defaults: + run: + shell: pwsh + strategy: + matrix: + VER: [v142, v143, clangcl] + GEN: [Visual Studio 17 2022, Ninja Multi-Config] + BIN: [x64] + STD: [99, 11, 17] + exclude: + - VER: clangcl + GEN: Ninja Multi-Config + include: + - VER: v142 + GEN: Visual Studio 17 2022 + BIN: x86 + STD: 99 + env: + NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip + NINJA_ROOT: C:\Tools\Ninja + VS_ROOT: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' + UseMultiToolTask: true # Better parallel MSBuild execution + EnforceProcessCountAcrossBuilds: 'true' # -=- + MultiProcMaxCount: '3' # -=- + CFLAGS: /W4 /WX + + steps: + - name: Cache Ninja install + if: matrix.GEN == 'Ninja Multi-Config' + id: ninja-install + uses: actions/cache@v4 + with: + path: | + C:\Tools\Ninja + key: ${{runner.os}}-ninja-${{env.NINJA_URL}} + + - name: Install Ninja + if: matrix.GEN == 'Ninja Multi-Config' && steps.ninja-install.outputs.cache-hit != 'true' + run: | + Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip + Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath ${env:NINJA_ROOT}\ + Remove-Item ~\Downloads\* + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + + - name: Configure (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A ${BIN} ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -S "${env:GITHUB_WORKSPACE}" ` + -B "${env:GITHUB_WORKSPACE}\build" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + + - name: Configure (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` + -S "${env:GITHUB_WORKSPACE}" ` + -B "${env:GITHUB_WORKSPACE}\build" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + + - name: Build (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config ${Config} ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers in $Config failed." } + } + + - name: Build (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config ${Config} ` + -- ` + -j ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers in $Config failed." } + } + + - name: Test + run: | + foreach ($Config in 'Release','Debug') { + & ctest ` + --test-dir "${env:GITHUB_WORKSPACE}\build" ` + --build-config ${Config} ` + --output-on-failure ` + --no-tests=error ` + --parallel ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "OpenCL-Headers tests in $Config failed." } + } + + - name: Install + run: | + & cmake ` + --install "${env:GITHUB_WORKSPACE}\build" ` + --prefix "${env:GITHUB_WORKSPACE}\install" ` + --config Release + if ($LASTEXITCODE -ne 0) { throw "OpenCL-Headers install failed." } + + - name: "Consume (MSBuild standalone): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A ${BIN} ` + -T ${{matrix.VER}} ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers standalone consume test failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config ${Config} ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-Headers standalone consume test in $Config failed." } + } + + - name: "Consume (Ninja Multi-Config standalone): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers standalone consume test failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-Headers standalone consume test in $Config failed." } + } + + - name: Consume (Emulate SDK presence) + run: | + New-Item -Type Directory -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL + New-Item -Type File -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL\OpenCLConfig.cmake -Value 'include("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeaders/OpenCLHeadersTargets.cmake")' + + - name: "Consume (MSBuild SDK): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A ${BIN} ` + -T ${{matrix.VER}} ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers in-SDK consume test failed." } + foreach ($Config in 'Release','Debug') { + cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config ${Config} ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-Headers in-SDK consume test in $Config failed." } + } + + - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_STANDARD=${{matrix.STD}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_C_STANDARD_REQUIRED=ON ` + -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + foreach ($Config in 'Release','Debug') { ` + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-Headers in-SDK consume test in $Config failed." } + } + + macos: + runs-on: macos-latest + needs: format + defaults: + run: + shell: bash + strategy: + matrix: + COMPILER: + - CC: /usr/bin/clang + CXX: /usr/bin/clang++ + # Disabled due to "Could not find compiler set in environment variable CC: gcc-11. + # - CC: gcc-11 + # CXX: g++-11 + # Disabled due to problems with the __API_AVAILABLE macro + # - CC: gcc-13 + # CXX: g++-13 + GEN: + - Xcode + - Ninja Multi-Config + STD: [99, 11, 17] + exclude: + # These entries are excluded, since XCode selects its own compiler + - COMPILER: + CC: gcc-11 + CXX: g++-11 + GEN: Xcode + - COMPILER: + CC: gcc-13 + CXX: g++-13 + GEN: Xcode + env: + CFLAGS: -Wall -Wextra -pedantic -Werror + CC: ${{matrix.COMPILER.CC}} + CXX: ${{matrix.COMPILER.CXX}} + steps: + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + + - name: Create Build Environment + run: | + # Install Ninja only if it's the selected generator and it's not available. + if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi; + if [[ ! `which pkg-config` ]]; then brew install pkg-config; fi && + cmake --version + + - name: Configure + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=ON + -D CMAKE_C_STANDARD=${{matrix.STD}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_C_STANDARD_REQUIRED=ON + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: | + cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` + cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-Headers/build + run: | + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + - name: Test install + run: cmake --build $GITHUB_WORKSPACE/build --target install --config Release + + - name: Consume (install) + run: cmake + -G "${{matrix.GEN}}" + -D CMAKE_C_STANDARD=${{matrix.STD}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_C_STANDARD_REQUIRED=ON + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/install" + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + cmake --build $GITHUB_WORKSPACE/build_install --config Release --parallel `sysctl -n hw.logicalcpu` && + cmake --build $GITHUB_WORKSPACE/build_install --config Debug --parallel `sysctl -n hw.logicalcpu` + + - name: Run consume test (install) + working-directory: ${{runner.workspace}}/OpenCL-Headers/build_install + run: | + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + - name: Test pkg-config + run: export PKG_CONFIG_PATH="$GITHUB_WORKSPACE/install/share/pkgconfig" && + pkg-config OpenCL-Headers --cflags | grep -q "\-I$GITHUB_WORKSPACE/install/include" + + android: + runs-on: ubuntu-latest + needs: format + defaults: + run: + shell: bash + strategy: + matrix: + ABI: + - arm64-v8a + - x86_64 + API_LEVEL: + - android-19 + - android-33 + CONFIG: + - Debug + - Release + env: + CFLAGS: -Wall -Wextra -pedantic -Werror + steps: + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + + - name: Configure + run: cmake + -G "Unix Makefiles" + -D BUILD_TESTING=ON + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake + -D ANDROID_ABI=${{matrix.ABI}} + -D ANDROID_PLATFORM=${{matrix.API_LEVEL}} + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: cmake --build $GITHUB_WORKSPACE/build --parallel `nproc` diff --git a/deps/opencl-headers/.github/workflows/release.yml b/deps/opencl-headers/.github/workflows/release.yml new file mode 100644 index 000000000..666e25488 --- /dev/null +++ b/deps/opencl-headers/.github/workflows/release.yml @@ -0,0 +1,71 @@ +name: Release + +on: + push: + tags: + - "v*" +env: + distroseries: jammy + +jobs: + release: + if: false + runs-on: ubuntu-latest + defaults: + run: + shell: bash + steps: + - name: Install prerequisites + run: sudo apt-get update -qq && sudo apt-get install -y cmake devscripts debhelper-compat=13 + + - name: Import GPG signing key + run: echo "${{ secrets.DEB_SIGNING_KEY }}" | gpg --import + + - name: Download and extract source code + run: | + wget -O $GITHUB_WORKSPACE/source.orig.tar.gz https://github.com/$GITHUB_REPOSITORY/archive/refs/tags/$GITHUB_REF_NAME.tar.gz + tar -xvf $GITHUB_WORKSPACE/source.orig.tar.gz + + - name: Configure project out-of-tree + run: cmake + -S $GITHUB_WORKSPACE/OpenCL-Headers* + -B $GITHUB_WORKSPACE/../build + -D CMAKE_BUILD_TYPE=Release + -D CMAKE_INSTALL_PREFIX=/usr + -D BUILD_TESTING=OFF + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D CPACK_DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + + - name: Generate packaging scripts + run: cmake + -D CMAKE_CACHE_PATH=$GITHUB_WORKSPACE/../build/CMakeCache.txt + -D ORIG_ARCHIVE=$GITHUB_WORKSPACE/source.orig.tar.gz + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D DEBIAN_DISTROSERIES=${{ env.distroseries }} + -D DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + -P $GITHUB_WORKSPACE/OpenCL-Headers*/cmake/DebSourcePkg.cmake + + - name: Build source package + run: | + cd $GITHUB_WORKSPACE/OpenCL-Headers*/ + debuild -S -sa + + - name: Build binary package + run: cpack + -G DEB + -C Release + -B $GITHUB_WORKSPACE/../build + --config $GITHUB_WORKSPACE/../build/CPackConfig.cmake + + # The following step does not depend on the previous step "Build binary package", + # but if the binary package build is unsuccessful, it is better not to push the + # source packages to the PPA + - name: Push source package to the PPA + run: dput ppa:${{ vars.PPA }} $GITHUB_WORKSPACE/*source.changes + + - name: Create GitHub release + uses: softprops/action-gh-release@v1 + with: + files: ${{ github.workspace }}/../build/*.deb diff --git a/deps/opencl-headers/.github/workflows/windows.yml b/deps/opencl-headers/.github/workflows/windows.yml deleted file mode 100644 index 7fd79c99c..000000000 --- a/deps/opencl-headers/.github/workflows/windows.yml +++ /dev/null @@ -1,247 +0,0 @@ -name: Windows - -on: [push, pull_request] - -jobs: - compatibility: - runs-on: windows-latest - strategy: - matrix: - VER: [v142, v143] - EXT: [ON, OFF] - GEN: [Visual Studio 17 2022] - BIN: [x64, x86] - STD: [99, 11, 17] - include: - - VER: v141 - EXT: OFF - GEN: Ninja Multi-Config - BIN: x64 - STD: 89 # /Za - env: - NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip - NINJA_ROOT: C:\Tools\Ninja - VS_ROOT: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' - UseMultiToolTask: true # Better parallel MSBuild execution - - steps: - - uses: actions/checkout@v2 - - - name: Cache Ninja install - if: matrix.GEN == 'Ninja Multi-Config' - id: ninja-install - uses: actions/cache@v2 - with: - path: | - C:\Tools\Ninja - key: ${{runner.os}}-ninja-${{env.NINJA_URL}} - - - name: Install Ninja - if: matrix.GEN == 'Ninja Multi-Config' && steps.ninja-install.outputs.cache-hit != 'true' - shell: pwsh - run: | - Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip - Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath ${env:NINJA_ROOT}\ - Remove-Item ~\Downloads\* - - - name: Configure (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: pwsh - run: | - $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -A $BIN ` - -T ${{matrix.VER}} ` - -D BUILD_TESTING=ON ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -S "${env:GITHUB_WORKSPACE}" ` - -B "${env:GITHUB_WORKSPACE}\build" - - - name: Configure (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: pwsh - run: | - $VER = switch ('${{matrix.VER}}') { ` - 'v141' {'14.1'} ` - 'v142' {'14.2'} ` - 'v143' {'14.3'} } - Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" - Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` - -D BUILD_TESTING=ON ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` - -S "${env:GITHUB_WORKSPACE}" ` - -B "${env:GITHUB_WORKSPACE}\build" - - - name: Build (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: pwsh - run: | - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\build" ` - --config ${Config} ` - -- ` - /verbosity:minimal ` - /maxCpuCount ` - /noLogo - } - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: pwsh - run: | - $VER = switch ('${{matrix.VER}}') { ` - 'v141' {'14.1'} ` - 'v142' {'14.2'} ` - 'v143' {'14.3'} } - Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" - Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\build" ` - --config ${Config} ` - -- ` - -j ${env:NUMBER_OF_PROCESSORS} - } - - - name: Test - shell: pwsh - run: | - foreach ($Config in 'Release','Debug') { ` - & ctest ` - --test-dir "${env:GITHUB_WORKSPACE}\build" ` - --build-config ${Config} ` - --output-on-failure ` - --parallel ${env:NUMBER_OF_PROCESSORS} - } - - - name: Install - shell: pwsh - run: | - & cmake ` - --install "${env:GITHUB_WORKSPACE}\build" ` - --prefix "${env:GITHUB_WORKSPACE}\install" ` - --config Release - - - name: Consume (PkgConfig - bare MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: pwsh - run: | - $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -A $BIN ` - -T ${{matrix.VER}} ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` - -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` - -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` - --config ${Config} ` - -- ` - /verbosity:minimal ` - /maxCpuCount ` - /noLogo ` - } - - - name: Consume (PkgConfig - bare Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: pwsh - run: | - $VER = switch ('${{matrix.VER}}') { ` - 'v141' {'14.1'} ` - 'v142' {'14.2'} ` - 'v143' {'14.3'} } - Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" - Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` - -D BUILD_TESTING=ON ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` - -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` - -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` - -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` - --config ${Config} ` - -- ` - -j ${env:NUMBER_OF_PROCESSORS} ` - } - - - name: Consume (Emulate SDK presence) - shell: pwsh - run: | - New-Item -Type Directory -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL - New-Item -Type File -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL\OpenCLConfig.cmake -Value 'include("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeaders/OpenCLHeadersTargets.cmake")' - - - name: Consume (PkgConfig - SDK MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: pwsh - run: | - $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -A $BIN ` - -T ${{matrix.VER}} ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` - -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` - -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` - --config ${Config} ` - -- ` - /verbosity:minimal ` - /maxCpuCount ` - /noLogo ` - } - - - name: Consume (PkgConfig - SDK Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: pwsh - run: | - $VER = switch ('${{matrix.VER}}') { ` - 'v141' {'14.1'} ` - 'v142' {'14.2'} ` - 'v143' {'14.3'} } - Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" - Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" - $C_FLAGS = '/W4 /WX' - & cmake ` - -G '${{matrix.GEN}}' ` - -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` - -D BUILD_TESTING=ON ` - -D CMAKE_C_FLAGS="${C_FLAGS}" ` - -D CMAKE_C_EXTENSIONS='${{matrix.EXT}}' ` - -D CMAKE_EXE_LINKER_FLAGS='/INCREMENTAL' ` - -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\install" ` - -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` - -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" - foreach ($Config in 'Release','Debug') { ` - & cmake ` - --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` - --config ${Config} ` - -- ` - -j ${env:NUMBER_OF_PROCESSORS} ` - } \ No newline at end of file diff --git a/deps/opencl-headers/.gitignore b/deps/opencl-headers/.gitignore new file mode 100644 index 000000000..c591e64c1 --- /dev/null +++ b/deps/opencl-headers/.gitignore @@ -0,0 +1,14 @@ +# Build dir +[Bb]uild/ + +# Install dir +[Ii]nstall/ + +# Package dir +[Pp]ackage[-_\s\d]*/ + +# Test dir +[Tt]esting/ + +# Visual Studio Code +.vscode diff --git a/deps/opencl-headers/CL/cl.h b/deps/opencl-headers/CL/cl.h index 6c700ab17..792e20cc8 100644 --- a/deps/opencl-headers/CL/cl.h +++ b/deps/opencl-headers/CL/cl.h @@ -112,9 +112,9 @@ typedef cl_uint cl_kernel_exec_info; typedef cl_bitfield cl_device_atomic_capabilities; typedef cl_bitfield cl_device_device_enqueue_capabilities; typedef cl_uint cl_khronos_vendor_id; -typedef cl_properties cl_mem_properties; -typedef cl_uint cl_version; +typedef cl_properties cl_mem_properties; #endif +typedef cl_uint cl_version; typedef struct _cl_image_format { cl_channel_order image_channel_order; @@ -569,11 +569,8 @@ typedef struct _cl_name_version { #define CL_RGx 0x10BB #define CL_RGBx 0x10BC #endif -#ifdef CL_VERSION_1_2 -#define CL_DEPTH 0x10BD -#define CL_DEPTH_STENCIL 0x10BE -#endif #ifdef CL_VERSION_2_0 +#define CL_DEPTH 0x10BD #define CL_sRGB 0x10BF #define CL_sRGBx 0x10C0 #define CL_sRGBA 0x10C1 @@ -597,9 +594,6 @@ typedef struct _cl_name_version { #define CL_UNSIGNED_INT32 0x10DC #define CL_HALF_FLOAT 0x10DD #define CL_FLOAT 0x10DE -#ifdef CL_VERSION_1_2 -#define CL_UNORM_INT24 0x10DF -#endif #ifdef CL_VERSION_2_1 #define CL_UNORM_INT_101010_2 0x10E0 #endif @@ -920,8 +914,6 @@ typedef struct _cl_name_version { /* cl_khronos_vendor_id */ #define CL_KHRONOS_VENDOR_ID_CODEPLAY 0x10004 -#ifdef CL_VERSION_3_0 - /* cl_version */ #define CL_VERSION_MAJOR_BITS (10) #define CL_VERSION_MINOR_BITS (10) @@ -945,9 +937,14 @@ typedef struct _cl_name_version { (((minor) & CL_VERSION_MINOR_MASK) << CL_VERSION_PATCH_BITS) | \ ((patch) & CL_VERSION_PATCH_MASK)) +/********************************************************************************************************/ + +/* CL_NO_PROTOTYPES implies CL_NO_CORE_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_CORE_PROTOTYPES) +#define CL_NO_CORE_PROTOTYPES #endif -/********************************************************************************************************/ +#if !defined(CL_NO_CORE_PROTOTYPES) /* Platform API */ extern CL_API_ENTRY cl_int CL_API_CALL @@ -1929,6 +1926,8 @@ clEnqueueTask(cl_command_queue command_queue, const cl_event * event_wait_list, cl_event * event) CL_API_SUFFIX__VERSION_1_2_DEPRECATED; +#endif /* !defined(CL_NO_CORE_PROTOTYPES) */ + #ifdef __cplusplus } #endif diff --git a/deps/opencl-headers/CL/cl_d3d10.h b/deps/opencl-headers/CL/cl_d3d10.h index 0d9950bed..6b56c775b 100644 --- a/deps/opencl-headers/CL/cl_d3d10.h +++ b/deps/opencl-headers/CL/cl_d3d10.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,8 +14,12 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_D3D10_H -#define __OPENCL_CL_D3D10_H +#ifndef OPENCL_CL_D3D10_H_ +#define OPENCL_CL_D3D10_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ #if defined(_MSC_VER) #if _MSC_VER >=1500 @@ -30,115 +34,224 @@ #pragma warning( pop ) #endif #endif + #include -#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif #ifdef __cplusplus extern "C" { #endif -/****************************************************************************** - * cl_khr_d3d10_sharing */ +/*************************************************************** +* cl_khr_d3d10_sharing +***************************************************************/ #define cl_khr_d3d10_sharing 1 +#define CL_KHR_D3D10_SHARING_EXTENSION_NAME \ + "cl_khr_d3d10_sharing" + -typedef cl_uint cl_d3d10_device_source_khr; -typedef cl_uint cl_d3d10_device_set_khr; +#define CL_KHR_D3D10_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/******************************************************************************/ +typedef cl_uint cl_d3d10_device_source_khr; +typedef cl_uint cl_d3d10_device_set_khr; -/* Error Codes */ -#define CL_INVALID_D3D10_DEVICE_KHR -1002 -#define CL_INVALID_D3D10_RESOURCE_KHR -1003 -#define CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR -1004 -#define CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR -1005 +/* Error codes */ +#define CL_INVALID_D3D10_DEVICE_KHR -1002 +#define CL_INVALID_D3D10_RESOURCE_KHR -1003 +#define CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR -1004 +#define CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR -1005 -/* cl_d3d10_device_source_nv */ -#define CL_D3D10_DEVICE_KHR 0x4010 -#define CL_D3D10_DXGI_ADAPTER_KHR 0x4011 +/* cl_d3d10_device_source_khr */ +#define CL_D3D10_DEVICE_KHR 0x4010 +#define CL_D3D10_DXGI_ADAPTER_KHR 0x4011 -/* cl_d3d10_device_set_nv */ -#define CL_PREFERRED_DEVICES_FOR_D3D10_KHR 0x4012 -#define CL_ALL_DEVICES_FOR_D3D10_KHR 0x4013 +/* cl_d3d10_device_set_khr */ +#define CL_PREFERRED_DEVICES_FOR_D3D10_KHR 0x4012 +#define CL_ALL_DEVICES_FOR_D3D10_KHR 0x4013 /* cl_context_info */ -#define CL_CONTEXT_D3D10_DEVICE_KHR 0x4014 -#define CL_CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR 0x402C +#define CL_CONTEXT_D3D10_DEVICE_KHR 0x4014 +#define CL_CONTEXT_D3D10_PREFER_SHARED_RESOURCES_KHR 0x402C /* cl_mem_info */ -#define CL_MEM_D3D10_RESOURCE_KHR 0x4015 +#define CL_MEM_D3D10_RESOURCE_KHR 0x4015 /* cl_image_info */ -#define CL_IMAGE_D3D10_SUBRESOURCE_KHR 0x4016 +#define CL_IMAGE_D3D10_SUBRESOURCE_KHR 0x4016 /* cl_command_type */ -#define CL_COMMAND_ACQUIRE_D3D10_OBJECTS_KHR 0x4017 -#define CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR 0x4018 +#define CL_COMMAND_ACQUIRE_D3D10_OBJECTS_KHR 0x4017 +#define CL_COMMAND_RELEASE_D3D10_OBJECTS_KHR 0x4018 -/******************************************************************************/ -typedef cl_int (CL_API_CALL *clGetDeviceIDsFromD3D10KHR_fn)( - cl_platform_id platform, +typedef cl_int CL_API_CALL +clGetDeviceIDsFromD3D10KHR_t( + cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, - void * d3d_object, - cl_d3d10_device_set_khr d3d_device_set, - cl_uint num_entries, - cl_device_id * devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D10BufferKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D10Buffer * resource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D10Texture2DKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D10Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D10Texture3DKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D10Texture3D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int (CL_API_CALL *clEnqueueAcquireD3D10ObjectsKHR_fn)( + void* d3d_object, + cl_d3d10_device_set_khr d3d_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDsFromD3D10KHR_t * +clGetDeviceIDsFromD3D10KHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_mem CL_API_CALL +clCreateFromD3D10BufferKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D10Buffer* resource, + cl_int* errcode_ret); + +typedef clCreateFromD3D10BufferKHR_t * +clCreateFromD3D10BufferKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_mem CL_API_CALL +clCreateFromD3D10Texture2DKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D10Texture2D* resource, + UINT subresource, + cl_int* errcode_ret); + +typedef clCreateFromD3D10Texture2DKHR_t * +clCreateFromD3D10Texture2DKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_mem CL_API_CALL +clCreateFromD3D10Texture3DKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D10Texture3D* resource, + UINT subresource, + cl_int* errcode_ret); + +typedef clCreateFromD3D10Texture3DKHR_t * +clCreateFromD3D10Texture3DKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueAcquireD3D10ObjectsKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -typedef cl_int (CL_API_CALL *clEnqueueReleaseD3D10ObjectsKHR_fn)( +typedef clEnqueueAcquireD3D10ObjectsKHR_t * +clEnqueueAcquireD3D10ObjectsKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueReleaseD3D10ObjectsKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseD3D10ObjectsKHR_t * +clEnqueueReleaseD3D10ObjectsKHR_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceIDsFromD3D10KHR( + cl_platform_id platform, + cl_d3d10_device_source_khr d3d_device_source, + void* d3d_object, + cl_d3d10_device_set_khr d3d_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D10BufferKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D10Texture2DKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D10Texture3DKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireD3D10ObjectsKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReleaseD3D10ObjectsKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_d3d10 ***************************************************************/ #define cl_intel_sharing_format_query_d3d10 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_D3D10_EXTENSION_NAME \ + "cl_intel_sharing_format_query_d3d10" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_D3D10_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* when cl_khr_d3d10_sharing is supported */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSupportedD3D10TextureFormatsINTEL( +typedef cl_int CL_API_CALL +clGetSupportedD3D10TextureFormatsINTEL_t( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, DXGI_FORMAT* d3d10_formats, - cl_uint* num_texture_formats) ; + cl_uint* num_texture_formats); + +typedef clGetSupportedD3D10TextureFormatsINTEL_t * +clGetSupportedD3D10TextureFormatsINTEL_fn ; -typedef cl_int (CL_API_CALL * -clGetSupportedD3D10TextureFormatsINTEL_fn)( +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedD3D10TextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -146,9 +259,10 @@ clGetSupportedD3D10TextureFormatsINTEL_fn)( DXGI_FORMAT* d3d10_formats, cl_uint* num_texture_formats) ; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_D3D10_H */ - +#endif /* OPENCL_CL_D3D10_H_ */ diff --git a/deps/opencl-headers/CL/cl_d3d11.h b/deps/opencl-headers/CL/cl_d3d11.h index 9393e5c84..384c8f428 100644 --- a/deps/opencl-headers/CL/cl_d3d11.h +++ b/deps/opencl-headers/CL/cl_d3d11.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,8 +14,12 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_D3D11_H -#define __OPENCL_CL_D3D11_H +#ifndef OPENCL_CL_D3D11_H_ +#define OPENCL_CL_D3D11_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ #if defined(_MSC_VER) #if _MSC_VER >=1500 @@ -30,116 +34,225 @@ #pragma warning( pop ) #endif #endif + #include -#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif #ifdef __cplusplus extern "C" { #endif -/****************************************************************************** - * cl_khr_d3d11_sharing */ +/*************************************************************** +* cl_khr_d3d11_sharing +***************************************************************/ #define cl_khr_d3d11_sharing 1 +#define CL_KHR_D3D11_SHARING_EXTENSION_NAME \ + "cl_khr_d3d11_sharing" + -typedef cl_uint cl_d3d11_device_source_khr; -typedef cl_uint cl_d3d11_device_set_khr; +#define CL_KHR_D3D11_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/******************************************************************************/ +typedef cl_uint cl_d3d11_device_source_khr; +typedef cl_uint cl_d3d11_device_set_khr; -/* Error Codes */ -#define CL_INVALID_D3D11_DEVICE_KHR -1006 -#define CL_INVALID_D3D11_RESOURCE_KHR -1007 -#define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR -1008 -#define CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR -1009 +/* Error codes */ +#define CL_INVALID_D3D11_DEVICE_KHR -1006 +#define CL_INVALID_D3D11_RESOURCE_KHR -1007 +#define CL_D3D11_RESOURCE_ALREADY_ACQUIRED_KHR -1008 +#define CL_D3D11_RESOURCE_NOT_ACQUIRED_KHR -1009 -/* cl_d3d11_device_source */ -#define CL_D3D11_DEVICE_KHR 0x4019 -#define CL_D3D11_DXGI_ADAPTER_KHR 0x401A +/* cl_d3d11_device_source_khr */ +#define CL_D3D11_DEVICE_KHR 0x4019 +#define CL_D3D11_DXGI_ADAPTER_KHR 0x401A -/* cl_d3d11_device_set */ -#define CL_PREFERRED_DEVICES_FOR_D3D11_KHR 0x401B -#define CL_ALL_DEVICES_FOR_D3D11_KHR 0x401C +/* cl_d3d11_device_set_khr */ +#define CL_PREFERRED_DEVICES_FOR_D3D11_KHR 0x401B +#define CL_ALL_DEVICES_FOR_D3D11_KHR 0x401C /* cl_context_info */ -#define CL_CONTEXT_D3D11_DEVICE_KHR 0x401D -#define CL_CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR 0x402D +#define CL_CONTEXT_D3D11_DEVICE_KHR 0x401D +#define CL_CONTEXT_D3D11_PREFER_SHARED_RESOURCES_KHR 0x402D /* cl_mem_info */ -#define CL_MEM_D3D11_RESOURCE_KHR 0x401E +#define CL_MEM_D3D11_RESOURCE_KHR 0x401E /* cl_image_info */ -#define CL_IMAGE_D3D11_SUBRESOURCE_KHR 0x401F +#define CL_IMAGE_D3D11_SUBRESOURCE_KHR 0x401F /* cl_command_type */ -#define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_KHR 0x4020 -#define CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR 0x4021 +#define CL_COMMAND_ACQUIRE_D3D11_OBJECTS_KHR 0x4020 +#define CL_COMMAND_RELEASE_D3D11_OBJECTS_KHR 0x4021 -/******************************************************************************/ -typedef cl_int (CL_API_CALL *clGetDeviceIDsFromD3D11KHR_fn)( - cl_platform_id platform, +typedef cl_int CL_API_CALL +clGetDeviceIDsFromD3D11KHR_t( + cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, - void * d3d_object, - cl_d3d11_device_set_khr d3d_device_set, - cl_uint num_entries, - cl_device_id * devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D11BufferKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D11Buffer * resource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D11Texture2DKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D11Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem (CL_API_CALL *clCreateFromD3D11Texture3DKHR_fn)( - cl_context context, - cl_mem_flags flags, - ID3D11Texture3D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL *clEnqueueAcquireD3D11ObjectsKHR_fn)( + void* d3d_object, + cl_d3d11_device_set_khr d3d_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDsFromD3D11KHR_t * +clGetDeviceIDsFromD3D11KHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL +clCreateFromD3D11BufferKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D11Buffer* resource, + cl_int* errcode_ret); + +typedef clCreateFromD3D11BufferKHR_t * +clCreateFromD3D11BufferKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL +clCreateFromD3D11Texture2DKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D11Texture2D* resource, + UINT subresource, + cl_int* errcode_ret); + +typedef clCreateFromD3D11Texture2DKHR_t * +clCreateFromD3D11Texture2DKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL +clCreateFromD3D11Texture3DKHR_t( + cl_context context, + cl_mem_flags flags, + ID3D11Texture3D* resource, + UINT subresource, + cl_int* errcode_ret); + +typedef clCreateFromD3D11Texture3DKHR_t * +clCreateFromD3D11Texture3DKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueAcquireD3D11ObjectsKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -typedef cl_int (CL_API_CALL *clEnqueueReleaseD3D11ObjectsKHR_fn)( +typedef clEnqueueAcquireD3D11ObjectsKHR_t * +clEnqueueAcquireD3D11ObjectsKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueReleaseD3D11ObjectsKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseD3D11ObjectsKHR_t * +clEnqueueReleaseD3D11ObjectsKHR_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceIDsFromD3D11KHR( + cl_platform_id platform, + cl_d3d11_device_source_khr d3d_device_source, + void* d3d_object, + cl_d3d11_device_set_khr d3d_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D11BufferKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D11Texture2DKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromD3D11Texture3DKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireD3D11ObjectsKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReleaseD3D11ObjectsKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_d3d11 ***************************************************************/ #define cl_intel_sharing_format_query_d3d11 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_D3D11_EXTENSION_NAME \ + "cl_intel_sharing_format_query_d3d11" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_D3D11_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* when cl_khr_d3d11_sharing is supported */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSupportedD3D11TextureFormatsINTEL( +typedef cl_int CL_API_CALL +clGetSupportedD3D11TextureFormatsINTEL_t( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, DXGI_FORMAT* d3d11_formats, - cl_uint* num_texture_formats) ; + cl_uint* num_texture_formats); + +typedef clGetSupportedD3D11TextureFormatsINTEL_t * +clGetSupportedD3D11TextureFormatsINTEL_fn ; -typedef cl_int (CL_API_CALL * -clGetSupportedD3D11TextureFormatsINTEL_fn)( +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedD3D11TextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -148,9 +261,10 @@ clGetSupportedD3D11TextureFormatsINTEL_fn)( DXGI_FORMAT* d3d11_formats, cl_uint* num_texture_formats) ; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_D3D11_H */ - +#endif /* OPENCL_CL_D3D11_H_ */ diff --git a/deps/opencl-headers/CL/cl_dx9_media_sharing.h b/deps/opencl-headers/CL/cl_dx9_media_sharing.h index fd03bbdc2..b079379d0 100644 --- a/deps/opencl-headers/CL/cl_dx9_media_sharing.h +++ b/deps/opencl-headers/CL/cl_dx9_media_sharing.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,23 +14,13 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_DX9_MEDIA_SHARING_H -#define __OPENCL_CL_DX9_MEDIA_SHARING_H +#ifndef OPENCL_CL_DX9_MEDIA_SHARING_H_ +#define OPENCL_CL_DX9_MEDIA_SHARING_H_ -#include -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/******************************************************************************/ -/* cl_khr_dx9_media_sharing */ -#define cl_khr_dx9_media_sharing 1 +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ -typedef cl_uint cl_dx9_media_adapter_type_khr; -typedef cl_uint cl_dx9_media_adapter_set_khr; - #if defined(_WIN32) #if defined(_MSC_VER) #if _MSC_VER >=1500 @@ -45,213 +35,340 @@ typedef cl_uint cl_dx9_media_adapter_set_khr; #pragma warning( pop ) #endif #endif -typedef struct _cl_dx9_surface_info_khr -{ - IDirect3DSurface9 *resource; - HANDLE shared_handle; -} cl_dx9_surface_info_khr; #endif +#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/*************************************************************** +* cl_khr_dx9_media_sharing +***************************************************************/ +#define cl_khr_dx9_media_sharing 1 +#define CL_KHR_DX9_MEDIA_SHARING_EXTENSION_NAME \ + "cl_khr_dx9_media_sharing" -/******************************************************************************/ -/* Error Codes */ -#define CL_INVALID_DX9_MEDIA_ADAPTER_KHR -1010 -#define CL_INVALID_DX9_MEDIA_SURFACE_KHR -1011 -#define CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR -1012 -#define CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR -1013 +#define CL_KHR_DX9_MEDIA_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_uint cl_dx9_media_adapter_type_khr; +typedef cl_uint cl_dx9_media_adapter_set_khr; + +#if defined(_WIN32) +typedef struct _cl_dx9_surface_info_khr { + IDirect3DSurface9* resource; + HANDLE shared_handle; +} cl_dx9_surface_info_khr; + +#endif /* defined(_WIN32) */ + +/* Error codes */ +#define CL_INVALID_DX9_MEDIA_ADAPTER_KHR -1010 +#define CL_INVALID_DX9_MEDIA_SURFACE_KHR -1011 +#define CL_DX9_MEDIA_SURFACE_ALREADY_ACQUIRED_KHR -1012 +#define CL_DX9_MEDIA_SURFACE_NOT_ACQUIRED_KHR -1013 /* cl_media_adapter_type_khr */ -#define CL_ADAPTER_D3D9_KHR 0x2020 -#define CL_ADAPTER_D3D9EX_KHR 0x2021 -#define CL_ADAPTER_DXVA_KHR 0x2022 +#define CL_ADAPTER_D3D9_KHR 0x2020 +#define CL_ADAPTER_D3D9EX_KHR 0x2021 +#define CL_ADAPTER_DXVA_KHR 0x2022 /* cl_media_adapter_set_khr */ -#define CL_PREFERRED_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2023 -#define CL_ALL_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2024 +#define CL_PREFERRED_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2023 +#define CL_ALL_DEVICES_FOR_DX9_MEDIA_ADAPTER_KHR 0x2024 /* cl_context_info */ -#define CL_CONTEXT_ADAPTER_D3D9_KHR 0x2025 -#define CL_CONTEXT_ADAPTER_D3D9EX_KHR 0x2026 -#define CL_CONTEXT_ADAPTER_DXVA_KHR 0x2027 +#define CL_CONTEXT_ADAPTER_D3D9_KHR 0x2025 +#define CL_CONTEXT_ADAPTER_D3D9EX_KHR 0x2026 +#define CL_CONTEXT_ADAPTER_DXVA_KHR 0x2027 /* cl_mem_info */ -#define CL_MEM_DX9_MEDIA_ADAPTER_TYPE_KHR 0x2028 -#define CL_MEM_DX9_MEDIA_SURFACE_INFO_KHR 0x2029 +#define CL_MEM_DX9_MEDIA_ADAPTER_TYPE_KHR 0x2028 +#define CL_MEM_DX9_MEDIA_SURFACE_INFO_KHR 0x2029 /* cl_image_info */ -#define CL_IMAGE_DX9_MEDIA_PLANE_KHR 0x202A +#define CL_IMAGE_DX9_MEDIA_PLANE_KHR 0x202A /* cl_command_type */ -#define CL_COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR 0x202B -#define CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR 0x202C - -/******************************************************************************/ - -typedef cl_int (CL_API_CALL *clGetDeviceIDsFromDX9MediaAdapterKHR_fn)( - cl_platform_id platform, - cl_uint num_media_adapters, - cl_dx9_media_adapter_type_khr * media_adapter_type, - void * media_adapters, - cl_dx9_media_adapter_set_khr media_adapter_set, - cl_uint num_entries, - cl_device_id * devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem (CL_API_CALL *clCreateFromDX9MediaSurfaceKHR_fn)( - cl_context context, - cl_mem_flags flags, +#define CL_COMMAND_ACQUIRE_DX9_MEDIA_SURFACES_KHR 0x202B +#define CL_COMMAND_RELEASE_DX9_MEDIA_SURFACES_KHR 0x202C + + +typedef cl_int CL_API_CALL +clGetDeviceIDsFromDX9MediaAdapterKHR_t( + cl_platform_id platform, + cl_uint num_media_adapters, + cl_dx9_media_adapter_type_khr* media_adapter_type, + void* media_adapters, + cl_dx9_media_adapter_set_khr media_adapter_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDsFromDX9MediaAdapterKHR_t * +clGetDeviceIDsFromDX9MediaAdapterKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL +clCreateFromDX9MediaSurfaceKHR_t( + cl_context context, + cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, - void * surface_info, - cl_uint plane, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; + void* surface_info, + cl_uint plane, + cl_int* errcode_ret); + +typedef clCreateFromDX9MediaSurfaceKHR_t * +clCreateFromDX9MediaSurfaceKHR_fn CL_API_SUFFIX__VERSION_1_2; -typedef cl_int (CL_API_CALL *clEnqueueAcquireDX9MediaSurfacesKHR_fn)( +typedef cl_int CL_API_CALL +clEnqueueAcquireDX9MediaSurfacesKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -typedef cl_int (CL_API_CALL *clEnqueueReleaseDX9MediaSurfacesKHR_fn)( +typedef clEnqueueAcquireDX9MediaSurfacesKHR_t * +clEnqueueAcquireDX9MediaSurfacesKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueReleaseDX9MediaSurfacesKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseDX9MediaSurfacesKHR_t * +clEnqueueReleaseDX9MediaSurfacesKHR_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/*************************************** -* cl_intel_dx9_media_sharing extension * -****************************************/ +extern CL_API_ENTRY cl_int CL_API_CALL +clGetDeviceIDsFromDX9MediaAdapterKHR( + cl_platform_id platform, + cl_uint num_media_adapters, + cl_dx9_media_adapter_type_khr* media_adapter_type, + void* media_adapters, + cl_dx9_media_adapter_set_khr media_adapter_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromDX9MediaSurfaceKHR( + cl_context context, + cl_mem_flags flags, + cl_dx9_media_adapter_type_khr adapter_type, + void* surface_info, + cl_uint plane, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireDX9MediaSurfacesKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReleaseDX9MediaSurfacesKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_intel_dx9_media_sharing +***************************************************************/ #define cl_intel_dx9_media_sharing 1 +#define CL_INTEL_DX9_MEDIA_SHARING_EXTENSION_NAME \ + "cl_intel_dx9_media_sharing" + -typedef cl_uint cl_dx9_device_source_intel; -typedef cl_uint cl_dx9_device_set_intel; +#define CL_INTEL_DX9_MEDIA_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/* error codes */ -#define CL_INVALID_DX9_DEVICE_INTEL -1010 -#define CL_INVALID_DX9_RESOURCE_INTEL -1011 -#define CL_DX9_RESOURCE_ALREADY_ACQUIRED_INTEL -1012 -#define CL_DX9_RESOURCE_NOT_ACQUIRED_INTEL -1013 +typedef cl_uint cl_dx9_device_source_intel; +typedef cl_uint cl_dx9_device_set_intel; + +/* Error codes */ +#define CL_INVALID_DX9_DEVICE_INTEL -1010 +#define CL_INVALID_DX9_RESOURCE_INTEL -1011 +#define CL_DX9_RESOURCE_ALREADY_ACQUIRED_INTEL -1012 +#define CL_DX9_RESOURCE_NOT_ACQUIRED_INTEL -1013 /* cl_dx9_device_source_intel */ -#define CL_D3D9_DEVICE_INTEL 0x4022 -#define CL_D3D9EX_DEVICE_INTEL 0x4070 -#define CL_DXVA_DEVICE_INTEL 0x4071 +#define CL_D3D9_DEVICE_INTEL 0x4022 +#define CL_D3D9EX_DEVICE_INTEL 0x4070 +#define CL_DXVA_DEVICE_INTEL 0x4071 /* cl_dx9_device_set_intel */ -#define CL_PREFERRED_DEVICES_FOR_DX9_INTEL 0x4024 -#define CL_ALL_DEVICES_FOR_DX9_INTEL 0x4025 +#define CL_PREFERRED_DEVICES_FOR_DX9_INTEL 0x4024 +#define CL_ALL_DEVICES_FOR_DX9_INTEL 0x4025 /* cl_context_info */ -#define CL_CONTEXT_D3D9_DEVICE_INTEL 0x4026 -#define CL_CONTEXT_D3D9EX_DEVICE_INTEL 0x4072 -#define CL_CONTEXT_DXVA_DEVICE_INTEL 0x4073 +#define CL_CONTEXT_D3D9_DEVICE_INTEL 0x4026 +#define CL_CONTEXT_D3D9EX_DEVICE_INTEL 0x4072 +#define CL_CONTEXT_DXVA_DEVICE_INTEL 0x4073 /* cl_mem_info */ -#define CL_MEM_DX9_RESOURCE_INTEL 0x4027 -#define CL_MEM_DX9_SHARED_HANDLE_INTEL 0x4074 +#define CL_MEM_DX9_RESOURCE_INTEL 0x4027 +#define CL_MEM_DX9_SHARED_HANDLE_INTEL 0x4074 /* cl_image_info */ -#define CL_IMAGE_DX9_PLANE_INTEL 0x4075 +#define CL_IMAGE_DX9_PLANE_INTEL 0x4075 /* cl_command_type */ -#define CL_COMMAND_ACQUIRE_DX9_OBJECTS_INTEL 0x402A -#define CL_COMMAND_RELEASE_DX9_OBJECTS_INTEL 0x402B -/******************************************************************************/ +#define CL_COMMAND_ACQUIRE_DX9_OBJECTS_INTEL 0x402A +#define CL_COMMAND_RELEASE_DX9_OBJECTS_INTEL 0x402B + + +typedef cl_int CL_API_CALL +clGetDeviceIDsFromDX9INTEL_t( + cl_platform_id platform, + cl_dx9_device_source_intel dx9_device_source, + void* dx9_object, + cl_dx9_device_set_intel dx9_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDsFromDX9INTEL_t * +clGetDeviceIDsFromDX9INTEL_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_mem CL_API_CALL +clCreateFromDX9MediaSurfaceINTEL_t( + cl_context context, + cl_mem_flags flags, + IDirect3DSurface9* resource, + HANDLE sharedHandle, + UINT plane, + cl_int* errcode_ret); + +typedef clCreateFromDX9MediaSurfaceINTEL_t * +clCreateFromDX9MediaSurfaceINTEL_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL +clEnqueueAcquireDX9ObjectsINTEL_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueAcquireDX9ObjectsINTEL_t * +clEnqueueAcquireDX9ObjectsINTEL_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL +clEnqueueReleaseDX9ObjectsINTEL_t( + cl_command_queue command_queue, + cl_uint num_objects, + cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseDX9ObjectsINTEL_t * +clEnqueueReleaseDX9ObjectsINTEL_fn CL_API_SUFFIX__VERSION_1_1; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9INTEL( - cl_platform_id platform, - cl_dx9_device_source_intel dx9_device_source, - void* dx9_object, - cl_dx9_device_set_intel dx9_device_set, - cl_uint num_entries, - cl_device_id* devices, - cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int (CL_API_CALL* clGetDeviceIDsFromDX9INTEL_fn)( - cl_platform_id platform, - cl_dx9_device_source_intel dx9_device_source, - void* dx9_object, - cl_dx9_device_set_intel dx9_device_set, - cl_uint num_entries, - cl_device_id* devices, - cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; + cl_platform_id platform, + cl_dx9_device_source_intel dx9_device_source, + void* dx9_object, + cl_dx9_device_set_intel dx9_device_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceINTEL( - cl_context context, - cl_mem_flags flags, - IDirect3DSurface9* resource, - HANDLE sharedHandle, - UINT plane, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_mem (CL_API_CALL *clCreateFromDX9MediaSurfaceINTEL_fn)( - cl_context context, - cl_mem_flags flags, - IDirect3DSurface9* resource, - HANDLE sharedHandle, - UINT plane, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; + cl_context context, + cl_mem_flags flags, + IDirect3DSurface9* resource, + HANDLE sharedHandle, + UINT plane, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9ObjectsINTEL( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int (CL_API_CALL *clEnqueueAcquireDX9ObjectsINTEL_fn)( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_1; + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_1; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9ObjectsINTEL( - cl_command_queue command_queue, - cl_uint num_objects, - cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int (CL_API_CALL *clEnqueueReleaseDX9ObjectsINTEL_fn)( - cl_command_queue command_queue, - cl_uint num_objects, - cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_1; + cl_command_queue command_queue, + cl_uint num_objects, + cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_1; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** * cl_intel_sharing_format_query_dx9 ***************************************************************/ #define cl_intel_sharing_format_query_dx9 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_DX9_EXTENSION_NAME \ + "cl_intel_sharing_format_query_dx9" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_DX9_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* when cl_khr_dx9_media_sharing or cl_intel_dx9_media_sharing is supported */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSupportedDX9MediaSurfaceFormatsINTEL( +typedef cl_int CL_API_CALL +clGetSupportedDX9MediaSurfaceFormatsINTEL_t( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, D3DFORMAT* dx9_formats, - cl_uint* num_surface_formats) ; + cl_uint* num_surface_formats); -typedef cl_int (CL_API_CALL * -clGetSupportedDX9MediaSurfaceFormatsINTEL_fn)( +typedef clGetSupportedDX9MediaSurfaceFormatsINTEL_t * +clGetSupportedDX9MediaSurfaceFormatsINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedDX9MediaSurfaceFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -260,9 +377,10 @@ clGetSupportedDX9MediaSurfaceFormatsINTEL_fn)( D3DFORMAT* dx9_formats, cl_uint* num_surface_formats) ; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_DX9_MEDIA_SHARING_H */ - +#endif /* OPENCL_CL_DX9_MEDIA_SHARING_H_ */ diff --git a/deps/opencl-headers/CL/cl_egl.h b/deps/opencl-headers/CL/cl_egl.h index 357a37c02..68aefec76 100644 --- a/deps/opencl-headers/CL/cl_egl.h +++ b/deps/opencl-headers/CL/cl_egl.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,107 +14,172 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_EGL_H -#define __OPENCL_CL_EGL_H +#ifndef OPENCL_CL_EGL_H_ +#define OPENCL_CL_EGL_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ #include +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif + #ifdef __cplusplus extern "C" { #endif +/*************************************************************** +* cl_khr_egl_image +***************************************************************/ +#define cl_khr_egl_image 1 +#define CL_KHR_EGL_IMAGE_EXTENSION_NAME \ + "cl_khr_egl_image" + + +#define CL_KHR_EGL_IMAGE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /* Command type for events created with clEnqueueAcquireEGLObjectsKHR */ -#define CL_COMMAND_EGL_FENCE_SYNC_OBJECT_KHR 0x202F -#define CL_COMMAND_ACQUIRE_EGL_OBJECTS_KHR 0x202D -#define CL_COMMAND_RELEASE_EGL_OBJECTS_KHR 0x202E +#define CL_COMMAND_EGL_FENCE_SYNC_OBJECT_KHR 0x202F +#define CL_COMMAND_ACQUIRE_EGL_OBJECTS_KHR 0x202D +#define CL_COMMAND_RELEASE_EGL_OBJECTS_KHR 0x202E /* Error type for clCreateFromEGLImageKHR */ -#define CL_INVALID_EGL_OBJECT_KHR -1093 -#define CL_EGL_RESOURCE_NOT_ACQUIRED_KHR -1092 +#define CL_INVALID_EGL_OBJECT_KHR -1093 +#define CL_EGL_RESOURCE_NOT_ACQUIRED_KHR -1092 /* CLeglImageKHR is an opaque handle to an EGLImage */ -typedef void* CLeglImageKHR; +typedef void* CLeglImageKHR; /* CLeglDisplayKHR is an opaque handle to an EGLDisplay */ -typedef void* CLeglDisplayKHR; - -/* CLeglSyncKHR is an opaque handle to an EGLSync object */ -typedef void* CLeglSyncKHR; +typedef void* CLeglDisplayKHR; /* properties passed to clCreateFromEGLImageKHR */ -typedef intptr_t cl_egl_image_properties_khr; +typedef intptr_t cl_egl_image_properties_khr; -#define cl_khr_egl_image 1 +typedef cl_mem CL_API_CALL +clCreateFromEGLImageKHR_t( + cl_context context, + CLeglDisplayKHR egldisplay, + CLeglImageKHR eglimage, + cl_mem_flags flags, + const cl_egl_image_properties_khr* properties, + cl_int* errcode_ret); -extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromEGLImageKHR(cl_context context, - CLeglDisplayKHR egldisplay, - CLeglImageKHR eglimage, - cl_mem_flags flags, - const cl_egl_image_properties_khr * properties, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem (CL_API_CALL *clCreateFromEGLImageKHR_fn)( - cl_context context, - CLeglDisplayKHR egldisplay, - CLeglImageKHR eglimage, - cl_mem_flags flags, - const cl_egl_image_properties_khr * properties, - cl_int * errcode_ret); +typedef clCreateFromEGLImageKHR_t * +clCreateFromEGLImageKHR_fn CL_API_SUFFIX__VERSION_1_0; +typedef cl_int CL_API_CALL +clEnqueueAcquireEGLObjectsKHR_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueAcquireEGLObjectsKHR(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int (CL_API_CALL *clEnqueueAcquireEGLObjectsKHR_fn)( +typedef clEnqueueAcquireEGLObjectsKHR_t * +clEnqueueAcquireEGLObjectsKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueReleaseEGLObjectsKHR_t( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event); + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseEGLObjectsKHR_t * +clEnqueueReleaseEGLObjectsKHR_fn CL_API_SUFFIX__VERSION_1_0; +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromEGLImageKHR( + cl_context context, + CLeglDisplayKHR egldisplay, + CLeglImageKHR eglimage, + cl_mem_flags flags, + const cl_egl_image_properties_khr* properties, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireEGLObjectsKHR( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueReleaseEGLObjectsKHR(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int (CL_API_CALL *clEnqueueReleaseEGLObjectsKHR_fn)( +clEnqueueReleaseEGLObjectsKHR( cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event); + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ +/*************************************************************** +* cl_khr_egl_event +***************************************************************/ #define cl_khr_egl_event 1 +#define CL_KHR_EGL_EVENT_EXTENSION_NAME \ + "cl_khr_egl_event" + + +#define CL_KHR_EGL_EVENT_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* CLeglDisplayKHR is an opaque handle to an EGLDisplay */ +/* type CLeglDisplayKHR */ + +/* CLeglSyncKHR is an opaque handle to an EGLSync object */ +typedef void* CLeglSyncKHR; + + +typedef cl_event CL_API_CALL +clCreateEventFromEGLSyncKHR_t( + cl_context context, + CLeglSyncKHR sync, + CLeglDisplayKHR display, + cl_int* errcode_ret); + +typedef clCreateEventFromEGLSyncKHR_t * +clCreateEventFromEGLSyncKHR_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_event CL_API_CALL -clCreateEventFromEGLSyncKHR(cl_context context, - CLeglSyncKHR sync, - CLeglDisplayKHR display, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_event (CL_API_CALL *clCreateEventFromEGLSyncKHR_fn)( - cl_context context, - CLeglSyncKHR sync, +clCreateEventFromEGLSyncKHR( + cl_context context, + CLeglSyncKHR sync, CLeglDisplayKHR display, - cl_int * errcode_ret); + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_EGL_H */ +#endif /* OPENCL_CL_EGL_H_ */ diff --git a/deps/opencl-headers/CL/cl_ext.h b/deps/opencl-headers/CL/cl_ext.h index 7f7712fc9..1a48985e1 100644 --- a/deps/opencl-headers/CL/cl_ext.h +++ b/deps/opencl-headers/CL/cl_ext.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,18 +14,36 @@ * limitations under the License. ******************************************************************************/ -/* cl_ext.h contains OpenCL extensions which don't have external */ -/* (OpenGL, D3D) dependencies. */ +#ifndef OPENCL_CL_EXT_H_ +#define OPENCL_CL_EXT_H_ -#ifndef __CL_EXT_H -#define __CL_EXT_H +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ + +#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif #ifdef __cplusplus extern "C" { #endif -#include - /*************************************************************** * cl_khr_command_buffer ***************************************************************/ @@ -33,6 +51,9 @@ extern "C" { #define CL_KHR_COMMAND_BUFFER_EXTENSION_NAME \ "cl_khr_command_buffer" + +#define CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION CL_MAKE_VERSION(0, 9, 5) + typedef cl_bitfield cl_device_command_buffer_capabilities_khr; typedef struct _cl_command_buffer_khr* cl_command_buffer_khr; typedef cl_uint cl_sync_point_khr; @@ -40,7 +61,7 @@ typedef cl_uint cl_command_buffer_info_khr; typedef cl_uint cl_command_buffer_state_khr; typedef cl_properties cl_command_buffer_properties_khr; typedef cl_bitfield cl_command_buffer_flags_khr; -typedef cl_properties cl_ndrange_kernel_command_properties_khr; +typedef cl_properties cl_command_properties_khr; typedef struct _cl_mutable_command_khr* cl_mutable_command_khr; /* cl_device_info */ @@ -56,7 +77,7 @@ typedef struct _cl_mutable_command_khr* cl_mutable_command_khr; /* cl_command_buffer_properties_khr */ #define CL_COMMAND_BUFFER_FLAGS_KHR 0x1293 -/* cl_command_buffer_flags_khr */ +/* cl_command_buffer_flags_khr - bitfield */ #define CL_COMMAND_BUFFER_SIMULTANEOUS_USE_KHR (1 << 0) /* Error codes */ @@ -70,58 +91,78 @@ typedef struct _cl_mutable_command_khr* cl_mutable_command_khr; #define CL_COMMAND_BUFFER_REFERENCE_COUNT_KHR 0x1296 #define CL_COMMAND_BUFFER_STATE_KHR 0x1297 #define CL_COMMAND_BUFFER_PROPERTIES_ARRAY_KHR 0x1298 +#define CL_COMMAND_BUFFER_CONTEXT_KHR 0x1299 /* cl_command_buffer_state_khr */ #define CL_COMMAND_BUFFER_STATE_RECORDING_KHR 0 #define CL_COMMAND_BUFFER_STATE_EXECUTABLE_KHR 1 #define CL_COMMAND_BUFFER_STATE_PENDING_KHR 2 -#define CL_COMMAND_BUFFER_STATE_INVALID_KHR 3 /* cl_command_type */ #define CL_COMMAND_COMMAND_BUFFER_KHR 0x12A8 -typedef cl_command_buffer_khr (CL_API_CALL * -clCreateCommandBufferKHR_fn)( +typedef cl_command_buffer_khr CL_API_CALL +clCreateCommandBufferKHR_t( cl_uint num_queues, const cl_command_queue* queues, const cl_command_buffer_properties_khr* properties, - cl_int* errcode_ret) ; + cl_int* errcode_ret); -typedef cl_int (CL_API_CALL * -clFinalizeCommandBufferKHR_fn)( - cl_command_buffer_khr command_buffer) ; +typedef clCreateCommandBufferKHR_t * +clCreateCommandBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clRetainCommandBufferKHR_fn)( - cl_command_buffer_khr command_buffer) ; +typedef cl_int CL_API_CALL +clFinalizeCommandBufferKHR_t( + cl_command_buffer_khr command_buffer); -typedef cl_int (CL_API_CALL * -clReleaseCommandBufferKHR_fn)( - cl_command_buffer_khr command_buffer) ; +typedef clFinalizeCommandBufferKHR_t * +clFinalizeCommandBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clEnqueueCommandBufferKHR_fn)( +typedef cl_int CL_API_CALL +clRetainCommandBufferKHR_t( + cl_command_buffer_khr command_buffer); + +typedef clRetainCommandBufferKHR_t * +clRetainCommandBufferKHR_fn ; + +typedef cl_int CL_API_CALL +clReleaseCommandBufferKHR_t( + cl_command_buffer_khr command_buffer); + +typedef clReleaseCommandBufferKHR_t * +clReleaseCommandBufferKHR_fn ; + +typedef cl_int CL_API_CALL +clEnqueueCommandBufferKHR_t( cl_uint num_queues, cl_command_queue* queues, cl_command_buffer_khr command_buffer, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, - cl_event* event) ; + cl_event* event); + +typedef clEnqueueCommandBufferKHR_t * +clEnqueueCommandBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandBarrierWithWaitListKHR_fn)( +typedef cl_int CL_API_CALL +clCommandBarrierWithWaitListKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandBarrierWithWaitListKHR_t * +clCommandBarrierWithWaitListKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandCopyBufferKHR_fn)( +typedef cl_int CL_API_CALL +clCommandCopyBufferKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, @@ -130,12 +171,16 @@ clCommandCopyBufferKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandCopyBufferKHR_t * +clCommandCopyBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandCopyBufferRectKHR_fn)( +typedef cl_int CL_API_CALL +clCommandCopyBufferRectKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_buffer, const size_t* src_origin, @@ -148,12 +193,16 @@ clCommandCopyBufferRectKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandCopyBufferRectKHR_t * +clCommandCopyBufferRectKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandCopyBufferToImageKHR_fn)( +typedef cl_int CL_API_CALL +clCommandCopyBufferToImageKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, @@ -162,12 +211,16 @@ clCommandCopyBufferToImageKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandCopyBufferToImageKHR_t * +clCommandCopyBufferToImageKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandCopyImageKHR_fn)( +typedef cl_int CL_API_CALL +clCommandCopyImageKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_image, cl_mem dst_image, const size_t* src_origin, @@ -176,12 +229,16 @@ clCommandCopyImageKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandCopyImageKHR_t * +clCommandCopyImageKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandCopyImageToBufferKHR_fn)( +typedef cl_int CL_API_CALL +clCommandCopyImageToBufferKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_image, cl_mem dst_buffer, const size_t* src_origin, @@ -190,12 +247,16 @@ clCommandCopyImageToBufferKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandCopyImageToBufferKHR_t * +clCommandCopyImageToBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandFillBufferKHR_fn)( +typedef cl_int CL_API_CALL +clCommandFillBufferKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem buffer, const void* pattern, size_t pattern_size, @@ -204,12 +265,16 @@ clCommandFillBufferKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandFillBufferKHR_t * +clCommandFillBufferKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandFillImageKHR_fn)( +typedef cl_int CL_API_CALL +clCommandFillImageKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem image, const void* fill_color, const size_t* origin, @@ -217,13 +282,16 @@ clCommandFillImageKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandFillImageKHR_t * +clCommandFillImageKHR_fn ; -typedef cl_int (CL_API_CALL * -clCommandNDRangeKernelKHR_fn)( +typedef cl_int CL_API_CALL +clCommandNDRangeKernelKHR_t( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, - const cl_ndrange_kernel_command_properties_khr* properties, + const cl_command_properties_khr* properties, cl_kernel kernel, cl_uint work_dim, const size_t* global_work_offset, @@ -232,17 +300,23 @@ clCommandNDRangeKernelKHR_fn)( cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, - cl_mutable_command_khr* mutable_handle) ; + cl_mutable_command_khr* mutable_handle); + +typedef clCommandNDRangeKernelKHR_t * +clCommandNDRangeKernelKHR_fn ; -typedef cl_int (CL_API_CALL * -clGetCommandBufferInfoKHR_fn)( +typedef cl_int CL_API_CALL +clGetCommandBufferInfoKHR_t( cl_command_buffer_khr command_buffer, cl_command_buffer_info_khr param_name, size_t param_value_size, void* param_value, - size_t* param_value_size_ret) ; + size_t* param_value_size_ret); + +typedef clGetCommandBufferInfoKHR_t * +clGetCommandBufferInfoKHR_fn ; -#ifndef CL_NO_PROTOTYPES +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_command_buffer_khr CL_API_CALL clCreateCommandBufferKHR( @@ -276,6 +350,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandBarrierWithWaitListKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_uint num_sync_points_in_wait_list, const cl_sync_point_khr* sync_point_wait_list, cl_sync_point_khr* sync_point, @@ -285,6 +360,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, @@ -299,6 +375,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferRectKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_buffer, const size_t* src_origin, @@ -317,6 +394,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyBufferToImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_buffer, cl_mem dst_image, size_t src_offset, @@ -331,6 +409,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_image, cl_mem dst_image, const size_t* src_origin, @@ -345,6 +424,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandCopyImageToBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem src_image, cl_mem dst_buffer, const size_t* src_origin, @@ -359,6 +439,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandFillBufferKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem buffer, const void* pattern, size_t pattern_size, @@ -373,6 +454,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandFillImageKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, + const cl_command_properties_khr* properties, cl_mem image, const void* fill_color, const size_t* origin, @@ -386,7 +468,7 @@ extern CL_API_ENTRY cl_int CL_API_CALL clCommandNDRangeKernelKHR( cl_command_buffer_khr command_buffer, cl_command_queue command_queue, - const cl_ndrange_kernel_command_properties_khr* properties, + const cl_command_properties_khr* properties, cl_kernel kernel, cl_uint work_dim, const size_t* global_work_offset, @@ -405,2106 +487,3741 @@ clGetCommandBufferInfoKHR( void* param_value, size_t* param_value_size_ret) ; -#endif /* CL_NO_PROTOTYPES */ +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/* cl_khr_fp64 extension - no extension #define since it has no functions */ -/* CL_DEVICE_DOUBLE_FP_CONFIG is defined in CL.h for OpenCL >= 120 */ - -#if CL_TARGET_OPENCL_VERSION <= 110 -#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 -#endif +/* From version 0.9.4 of the extension */ -/* cl_khr_fp16 extension - no extension #define since it has no functions */ -#define CL_DEVICE_HALF_FP_CONFIG 0x1033 +typedef cl_int CL_API_CALL +clCommandSVMMemcpyKHR_t( + cl_command_buffer_khr command_buffer, + cl_command_queue command_queue, + const cl_command_properties_khr* properties, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_sync_points_in_wait_list, + const cl_sync_point_khr* sync_point_wait_list, + cl_sync_point_khr* sync_point, + cl_mutable_command_khr* mutable_handle); -/* Memory object destruction - * - * Apple extension for use to manage externally allocated buffers used with cl_mem objects with CL_MEM_USE_HOST_PTR - * - * Registers a user callback function that will be called when the memory object is deleted and its resources - * freed. Each call to clSetMemObjectCallbackFn registers the specified user callback function on a callback - * stack associated with memobj. The registered user callback functions are called in the reverse order in - * which they were registered. The user callback functions are called and then the memory object is deleted - * and its resources freed. This provides a mechanism for the application (and libraries) using memobj to be - * notified when the memory referenced by host_ptr, specified when the memory object is created and used as - * the storage bits for the memory object, can be reused or freed. - * - * The application may not call CL api's with the cl_mem object passed to the pfn_notify. - * - * Please check for the "cl_APPLE_SetMemObjectDestructor" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) - * before using. - */ -#define cl_APPLE_SetMemObjectDestructor 1 -extern CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorAPPLE( cl_mem memobj, - void (* pfn_notify)(cl_mem memobj, void * user_data), - void * user_data) CL_API_SUFFIX__VERSION_1_0; +typedef clCommandSVMMemcpyKHR_t * +clCommandSVMMemcpyKHR_fn CL_API_SUFFIX__VERSION_2_0; +typedef cl_int CL_API_CALL +clCommandSVMMemFillKHR_t( + cl_command_buffer_khr command_buffer, + cl_command_queue command_queue, + const cl_command_properties_khr* properties, + void* svm_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_sync_points_in_wait_list, + const cl_sync_point_khr* sync_point_wait_list, + cl_sync_point_khr* sync_point, + cl_mutable_command_khr* mutable_handle); -/* Context Logging Functions - * - * The next three convenience functions are intended to be used as the pfn_notify parameter to clCreateContext(). - * Please check for the "cl_APPLE_ContextLoggingFunctions" extension using clGetDeviceInfo(CL_DEVICE_EXTENSIONS) - * before using. - * - * clLogMessagesToSystemLog forwards on all log messages to the Apple System Logger - */ -#define cl_APPLE_ContextLoggingFunctions 1 -extern CL_API_ENTRY void CL_API_CALL clLogMessagesToSystemLogAPPLE( const char * errstr, - const void * private_info, - size_t cb, - void * user_data) CL_API_SUFFIX__VERSION_1_0; - -/* clLogMessagesToStdout sends all log messages to the file descriptor stdout */ -extern CL_API_ENTRY void CL_API_CALL clLogMessagesToStdoutAPPLE( const char * errstr, - const void * private_info, - size_t cb, - void * user_data) CL_API_SUFFIX__VERSION_1_0; - -/* clLogMessagesToStderr sends all log messages to the file descriptor stderr */ -extern CL_API_ENTRY void CL_API_CALL clLogMessagesToStderrAPPLE( const char * errstr, - const void * private_info, - size_t cb, - void * user_data) CL_API_SUFFIX__VERSION_1_0; - - -/************************ -* cl_khr_icd extension * -************************/ -#define cl_khr_icd 1 +typedef clCommandSVMMemFillKHR_t * +clCommandSVMMemFillKHR_fn CL_API_SUFFIX__VERSION_2_0; -/* cl_platform_info */ -#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/* Additional Error Codes */ -#define CL_PLATFORM_NOT_FOUND_KHR -1001 +extern CL_API_ENTRY cl_int CL_API_CALL +clCommandSVMMemcpyKHR( + cl_command_buffer_khr command_buffer, + cl_command_queue command_queue, + const cl_command_properties_khr* properties, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_sync_points_in_wait_list, + const cl_sync_point_khr* sync_point_wait_list, + cl_sync_point_khr* sync_point, + cl_mutable_command_khr* mutable_handle) CL_API_SUFFIX__VERSION_2_0; extern CL_API_ENTRY cl_int CL_API_CALL -clIcdGetPlatformIDsKHR(cl_uint num_entries, - cl_platform_id * platforms, - cl_uint * num_platforms); +clCommandSVMMemFillKHR( + cl_command_buffer_khr command_buffer, + cl_command_queue command_queue, + const cl_command_properties_khr* properties, + void* svm_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_sync_points_in_wait_list, + const cl_sync_point_khr* sync_point_wait_list, + cl_sync_point_khr* sync_point, + cl_mutable_command_khr* mutable_handle) CL_API_SUFFIX__VERSION_2_0; -typedef cl_int -(CL_API_CALL *clIcdGetPlatformIDsKHR_fn)(cl_uint num_entries, - cl_platform_id * platforms, - cl_uint * num_platforms); +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_khr_command_buffer_multi_device +***************************************************************/ +#define cl_khr_command_buffer_multi_device 1 +#define CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_NAME \ + "cl_khr_command_buffer_multi_device" -/******************************* - * cl_khr_il_program extension * - *******************************/ -#define cl_khr_il_program 1 +#define CL_KHR_COMMAND_BUFFER_MULTI_DEVICE_EXTENSION_VERSION CL_MAKE_VERSION(0, 9, 1) -/* New property to clGetDeviceInfo for retrieving supported intermediate - * languages - */ -#define CL_DEVICE_IL_VERSION_KHR 0x105B +typedef cl_bitfield cl_platform_command_buffer_capabilities_khr; -/* New property to clGetProgramInfo for retrieving for retrieving the IL of a - * program - */ -#define CL_PROGRAM_IL_KHR 0x1169 +/* cl_platform_info */ +#define CL_PLATFORM_COMMAND_BUFFER_CAPABILITIES_KHR 0x0908 -extern CL_API_ENTRY cl_program CL_API_CALL -clCreateProgramWithILKHR(cl_context context, - const void * il, - size_t length, - cl_int * errcode_ret); - -typedef cl_program -(CL_API_CALL *clCreateProgramWithILKHR_fn)(cl_context context, - const void * il, - size_t length, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -/* Extension: cl_khr_image2d_from_buffer - * - * This extension allows a 2D image to be created from a cl_mem buffer without - * a copy. The type associated with a 2D image created from a buffer in an - * OpenCL program is image2d_t. Both the sampler and sampler-less read_image - * built-in functions are supported for 2D images and 2D images created from - * a buffer. Similarly, the write_image built-ins are also supported for 2D - * images created from a buffer. - * - * When the 2D image from buffer is created, the client must specify the - * width, height, image format (i.e. channel order and channel data type) - * and optionally the row pitch. - * - * The pitch specified must be a multiple of - * CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR pixels. - * The base address of the buffer must be aligned to - * CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR pixels. - */ +/* cl_platform_command_buffer_capabilities_khr - bitfield */ +#define CL_COMMAND_BUFFER_PLATFORM_UNIVERSAL_SYNC_KHR (1 << 0) +#define CL_COMMAND_BUFFER_PLATFORM_REMAP_QUEUES_KHR (1 << 1) +#define CL_COMMAND_BUFFER_PLATFORM_AUTOMATIC_REMAP_KHR (1 << 2) -#define CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR 0x104A -#define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR 0x104B +/* cl_device_info */ +#define CL_DEVICE_COMMAND_BUFFER_NUM_SYNC_DEVICES_KHR 0x12AB +#define CL_DEVICE_COMMAND_BUFFER_SYNC_DEVICES_KHR 0x12AC +/* cl_device_command_buffer_capabilities_khr - bitfield */ +#define CL_COMMAND_BUFFER_CAPABILITY_MULTIPLE_QUEUE_KHR (1 << 4) -/************************************** - * cl_khr_initialize_memory extension * - **************************************/ +/* cl_command_buffer_flags_khr - bitfield */ +#define CL_COMMAND_BUFFER_DEVICE_SIDE_SYNC_KHR (1 << 2) -#define CL_CONTEXT_MEMORY_INITIALIZE_KHR 0x2030 +typedef cl_command_buffer_khr CL_API_CALL +clRemapCommandBufferKHR_t( + cl_command_buffer_khr command_buffer, + cl_bool automatic, + cl_uint num_queues, + const cl_command_queue* queues, + cl_uint num_handles, + const cl_mutable_command_khr* handles, + cl_mutable_command_khr* handles_ret, + cl_int* errcode_ret); -/************************************** - * cl_khr_terminate_context extension * - **************************************/ +typedef clRemapCommandBufferKHR_t * +clRemapCommandBufferKHR_fn ; -#define CL_CONTEXT_TERMINATED_KHR -1121 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -#define CL_DEVICE_TERMINATE_CAPABILITY_KHR 0x2031 -#define CL_CONTEXT_TERMINATE_KHR 0x2032 +extern CL_API_ENTRY cl_command_buffer_khr CL_API_CALL +clRemapCommandBufferKHR( + cl_command_buffer_khr command_buffer, + cl_bool automatic, + cl_uint num_queues, + const cl_command_queue* queues, + cl_uint num_handles, + const cl_mutable_command_khr* handles, + cl_mutable_command_khr* handles_ret, + cl_int* errcode_ret) ; -#define cl_khr_terminate_context 1 -extern CL_API_ENTRY cl_int CL_API_CALL -clTerminateContextKHR(cl_context context) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -typedef cl_int -(CL_API_CALL *clTerminateContextKHR_fn)(cl_context context) CL_API_SUFFIX__VERSION_1_2; +/*************************************************************** +* cl_khr_command_buffer_mutable_dispatch +***************************************************************/ +#define cl_khr_command_buffer_mutable_dispatch 1 +#define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_NAME \ + "cl_khr_command_buffer_mutable_dispatch" + + +#define CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION CL_MAKE_VERSION(0, 9, 3) + +typedef cl_uint cl_command_buffer_update_type_khr; +typedef cl_bitfield cl_mutable_dispatch_fields_khr; +typedef cl_uint cl_mutable_command_info_khr; +typedef struct _cl_mutable_dispatch_arg_khr { + cl_uint arg_index; + size_t arg_size; + const void* arg_value; +} cl_mutable_dispatch_arg_khr; +typedef struct _cl_mutable_dispatch_exec_info_khr { + cl_uint param_name; + size_t param_value_size; + const void* param_value; +} cl_mutable_dispatch_exec_info_khr; +typedef struct _cl_mutable_dispatch_config_khr { + cl_mutable_command_khr command; + cl_uint num_args; + cl_uint num_svm_args; + cl_uint num_exec_infos; + cl_uint work_dim; + const cl_mutable_dispatch_arg_khr* arg_list; + const cl_mutable_dispatch_arg_khr* arg_svm_list; + const cl_mutable_dispatch_exec_info_khr* exec_info_list; + const size_t* global_work_offset; + const size_t* global_work_size; + const size_t* local_work_size; +} cl_mutable_dispatch_config_khr; +typedef cl_bitfield cl_mutable_dispatch_asserts_khr; + +/* cl_command_buffer_flags_khr - bitfield */ +#define CL_COMMAND_BUFFER_MUTABLE_KHR (1 << 1) +/* Error codes */ +#define CL_INVALID_MUTABLE_COMMAND_KHR -1141 -/* - * Extension: cl_khr_spir - * - * This extension adds support to create an OpenCL program object from a - * Standard Portable Intermediate Representation (SPIR) instance - */ +/* cl_device_info */ +#define CL_DEVICE_MUTABLE_DISPATCH_CAPABILITIES_KHR 0x12B0 + +/* cl_command_properties_khr */ +#define CL_MUTABLE_DISPATCH_UPDATABLE_FIELDS_KHR 0x12B1 + +/* cl_mutable_dispatch_fields_khr - bitfield */ +#define CL_MUTABLE_DISPATCH_GLOBAL_OFFSET_KHR (1 << 0) +#define CL_MUTABLE_DISPATCH_GLOBAL_SIZE_KHR (1 << 1) +#define CL_MUTABLE_DISPATCH_LOCAL_SIZE_KHR (1 << 2) +#define CL_MUTABLE_DISPATCH_ARGUMENTS_KHR (1 << 3) +#define CL_MUTABLE_DISPATCH_EXEC_INFO_KHR (1 << 4) + +/* cl_mutable_command_info_khr */ +#define CL_MUTABLE_COMMAND_COMMAND_QUEUE_KHR 0x12A0 +#define CL_MUTABLE_COMMAND_COMMAND_BUFFER_KHR 0x12A1 +#define CL_MUTABLE_COMMAND_COMMAND_TYPE_KHR 0x12AD +#define CL_MUTABLE_COMMAND_PROPERTIES_ARRAY_KHR 0x12A2 +#define CL_MUTABLE_DISPATCH_KERNEL_KHR 0x12A3 +#define CL_MUTABLE_DISPATCH_DIMENSIONS_KHR 0x12A4 +#define CL_MUTABLE_DISPATCH_GLOBAL_WORK_OFFSET_KHR 0x12A5 +#define CL_MUTABLE_DISPATCH_GLOBAL_WORK_SIZE_KHR 0x12A6 +#define CL_MUTABLE_DISPATCH_LOCAL_WORK_SIZE_KHR 0x12A7 + +/* cl_command_buffer_update_type_khr */ +#define CL_STRUCTURE_TYPE_MUTABLE_DISPATCH_CONFIG_KHR 0 -#define CL_DEVICE_SPIR_VERSIONS 0x40E0 -#define CL_PROGRAM_BINARY_TYPE_INTERMEDIATE 0x40E1 +/* cl_command_buffer_properties_khr */ +#define CL_COMMAND_BUFFER_MUTABLE_DISPATCH_ASSERTS_KHR 0x12B7 +/* cl_command_properties_khr */ +#define CL_MUTABLE_DISPATCH_ASSERTS_KHR 0x12B8 -/***************************************** - * cl_khr_create_command_queue extension * - *****************************************/ -#define cl_khr_create_command_queue 1 +/* cl_mutable_dispatch_asserts_khr - bitfield */ +#define CL_MUTABLE_DISPATCH_ASSERT_NO_ADDITIONAL_WORK_GROUPS_KHR (1 << 0) -typedef cl_properties cl_queue_properties_khr; -extern CL_API_ENTRY cl_command_queue CL_API_CALL -clCreateCommandQueueWithPropertiesKHR(cl_context context, - cl_device_id device, - const cl_queue_properties_khr* properties, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_command_queue -(CL_API_CALL *clCreateCommandQueueWithPropertiesKHR_fn)(cl_context context, - cl_device_id device, - const cl_queue_properties_khr* properties, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; - - -/****************************************** -* cl_nv_device_attribute_query extension * -******************************************/ - -/* cl_nv_device_attribute_query extension - no extension #define since it has no functions */ -#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 -#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 -#define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002 -#define CL_DEVICE_WARP_SIZE_NV 0x4003 -#define CL_DEVICE_GPU_OVERLAP_NV 0x4004 -#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005 -#define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006 - - -/********************************* -* cl_amd_device_attribute_query * -*********************************/ - -#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036 -#define CL_DEVICE_TOPOLOGY_AMD 0x4037 -#define CL_DEVICE_BOARD_NAME_AMD 0x4038 -#define CL_DEVICE_GLOBAL_FREE_MEMORY_AMD 0x4039 -#define CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD 0x4040 -#define CL_DEVICE_SIMD_WIDTH_AMD 0x4041 -#define CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD 0x4042 -#define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043 -#define CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD 0x4044 -#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD 0x4045 -#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD 0x4046 -#define CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD 0x4047 -#define CL_DEVICE_LOCAL_MEM_BANKS_AMD 0x4048 -#define CL_DEVICE_THREAD_TRACE_SUPPORTED_AMD 0x4049 -#define CL_DEVICE_GFXIP_MAJOR_AMD 0x404A -#define CL_DEVICE_GFXIP_MINOR_AMD 0x404B -#define CL_DEVICE_AVAILABLE_ASYNC_QUEUES_AMD 0x404C -#define CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_AMD 0x4030 -#define CL_DEVICE_MAX_WORK_GROUP_SIZE_AMD 0x4031 -#define CL_DEVICE_PREFERRED_CONSTANT_BUFFER_SIZE_AMD 0x4033 -#define CL_DEVICE_PCIE_ID_AMD 0x4034 - - -/********************************* -* cl_arm_printf extension -*********************************/ - -#define CL_PRINTF_CALLBACK_ARM 0x40B0 -#define CL_PRINTF_BUFFERSIZE_ARM 0x40B1 - - -/*********************************** -* cl_ext_device_fission extension -***********************************/ -#define cl_ext_device_fission 1 - -extern CL_API_ENTRY cl_int CL_API_CALL -clReleaseDeviceEXT(cl_device_id device) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int -(CL_API_CALL *clReleaseDeviceEXT_fn)(cl_device_id device) CL_API_SUFFIX__VERSION_1_1; - -extern CL_API_ENTRY cl_int CL_API_CALL -clRetainDeviceEXT(cl_device_id device) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int -(CL_API_CALL *clRetainDeviceEXT_fn)(cl_device_id device) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_ulong cl_device_partition_property_ext; -extern CL_API_ENTRY cl_int CL_API_CALL -clCreateSubDevicesEXT(cl_device_id in_device, - const cl_device_partition_property_ext * properties, - cl_uint num_entries, - cl_device_id * out_devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int -(CL_API_CALL * clCreateSubDevicesEXT_fn)(cl_device_id in_device, - const cl_device_partition_property_ext * properties, - cl_uint num_entries, - cl_device_id * out_devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_1; +typedef cl_int CL_API_CALL +clUpdateMutableCommandsKHR_t( + cl_command_buffer_khr command_buffer, + cl_uint num_configs, + const cl_command_buffer_update_type_khr* config_types, + const void** configs); -/* cl_device_partition_property_ext */ -#define CL_DEVICE_PARTITION_EQUALLY_EXT 0x4050 -#define CL_DEVICE_PARTITION_BY_COUNTS_EXT 0x4051 -#define CL_DEVICE_PARTITION_BY_NAMES_EXT 0x4052 -#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT 0x4053 - -/* clDeviceGetInfo selectors */ -#define CL_DEVICE_PARENT_DEVICE_EXT 0x4054 -#define CL_DEVICE_PARTITION_TYPES_EXT 0x4055 -#define CL_DEVICE_AFFINITY_DOMAINS_EXT 0x4056 -#define CL_DEVICE_REFERENCE_COUNT_EXT 0x4057 -#define CL_DEVICE_PARTITION_STYLE_EXT 0x4058 - -/* error codes */ -#define CL_DEVICE_PARTITION_FAILED_EXT -1057 -#define CL_INVALID_PARTITION_COUNT_EXT -1058 -#define CL_INVALID_PARTITION_NAME_EXT -1059 - -/* CL_AFFINITY_DOMAINs */ -#define CL_AFFINITY_DOMAIN_L1_CACHE_EXT 0x1 -#define CL_AFFINITY_DOMAIN_L2_CACHE_EXT 0x2 -#define CL_AFFINITY_DOMAIN_L3_CACHE_EXT 0x3 -#define CL_AFFINITY_DOMAIN_L4_CACHE_EXT 0x4 -#define CL_AFFINITY_DOMAIN_NUMA_EXT 0x10 -#define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT 0x100 - -/* cl_device_partition_property_ext list terminators */ -#define CL_PROPERTIES_LIST_END_EXT ((cl_device_partition_property_ext) 0) -#define CL_PARTITION_BY_COUNTS_LIST_END_EXT ((cl_device_partition_property_ext) 0) -#define CL_PARTITION_BY_NAMES_LIST_END_EXT ((cl_device_partition_property_ext) 0 - 1) - - -/*********************************** - * cl_ext_migrate_memobject extension definitions - ***********************************/ -#define cl_ext_migrate_memobject 1 +typedef clUpdateMutableCommandsKHR_t * +clUpdateMutableCommandsKHR_fn ; -typedef cl_bitfield cl_mem_migration_flags_ext; +typedef cl_int CL_API_CALL +clGetMutableCommandInfoKHR_t( + cl_mutable_command_khr command, + cl_mutable_command_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); -#define CL_MIGRATE_MEM_OBJECT_HOST_EXT 0x1 +typedef clGetMutableCommandInfoKHR_t * +clGetMutableCommandInfoKHR_fn ; -#define CL_COMMAND_MIGRATE_MEM_OBJECT_EXT 0x4040 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMigrateMemObjectEXT(cl_command_queue command_queue, - cl_uint num_mem_objects, - const cl_mem * mem_objects, - cl_mem_migration_flags_ext flags, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event); - -typedef cl_int -(CL_API_CALL *clEnqueueMigrateMemObjectEXT_fn)(cl_command_queue command_queue, - cl_uint num_mem_objects, - const cl_mem * mem_objects, - cl_mem_migration_flags_ext flags, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event); +clUpdateMutableCommandsKHR( + cl_command_buffer_khr command_buffer, + cl_uint num_configs, + const cl_command_buffer_update_type_khr* config_types, + const void** configs) ; +extern CL_API_ENTRY cl_int CL_API_CALL +clGetMutableCommandInfoKHR( + cl_mutable_command_khr command, + cl_mutable_command_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) ; -/********************************* -* cl_ext_cxx_for_opencl extension -*********************************/ -#define cl_ext_cxx_for_opencl 1 +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -#define CL_DEVICE_CXX_FOR_OPENCL_NUMERIC_VERSION_EXT 0x4230 +/*************************************************************** +* cl_khr_fp64 +***************************************************************/ +#define cl_khr_fp64 1 +#define CL_KHR_FP64_EXTENSION_NAME \ + "cl_khr_fp64" -/********************************* -* cl_qcom_ext_host_ptr extension -*********************************/ -#define cl_qcom_ext_host_ptr 1 -#define CL_MEM_EXT_HOST_PTR_QCOM (1 << 29) +#define CL_KHR_FP64_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -#define CL_DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM 0x40A0 -#define CL_DEVICE_PAGE_SIZE_QCOM 0x40A1 -#define CL_IMAGE_ROW_ALIGNMENT_QCOM 0x40A2 -#define CL_IMAGE_SLICE_ALIGNMENT_QCOM 0x40A3 -#define CL_MEM_HOST_UNCACHED_QCOM 0x40A4 -#define CL_MEM_HOST_WRITEBACK_QCOM 0x40A5 -#define CL_MEM_HOST_WRITETHROUGH_QCOM 0x40A6 -#define CL_MEM_HOST_WRITE_COMBINING_QCOM 0x40A7 +#if !defined(CL_VERSION_1_2) +/* cl_device_info - defined in CL.h for OpenCL 1.2 and newer */ +#define CL_DEVICE_DOUBLE_FP_CONFIG 0x1032 -typedef cl_uint cl_image_pitch_info_qcom; +#endif /* !defined(CL_VERSION_1_2) */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetDeviceImageInfoQCOM(cl_device_id device, - size_t image_width, - size_t image_height, - const cl_image_format *image_format, - cl_image_pitch_info_qcom param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret); +/*************************************************************** +* cl_khr_fp16 +***************************************************************/ +#define cl_khr_fp16 1 +#define CL_KHR_FP16_EXTENSION_NAME \ + "cl_khr_fp16" -typedef struct _cl_mem_ext_host_ptr -{ - /* Type of external memory allocation. */ - /* Legal values will be defined in layered extensions. */ - cl_uint allocation_type; - /* Host cache policy for this external memory allocation. */ - cl_uint host_cache_policy; +#define CL_KHR_FP16_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -} cl_mem_ext_host_ptr; +/* cl_device_info */ +#define CL_DEVICE_HALF_FP_CONFIG 0x1033 +/*************************************************************** +* cl_APPLE_SetMemObjectDestructor +***************************************************************/ +#define cl_APPLE_SetMemObjectDestructor 1 +#define CL_APPLE_SETMEMOBJECTDESTRUCTOR_EXTENSION_NAME \ + "cl_APPLE_SetMemObjectDestructor" -/******************************************* -* cl_qcom_ext_host_ptr_iocoherent extension -********************************************/ -/* Cache policy specifying io-coherence */ -#define CL_MEM_HOST_IOCOHERENT_QCOM 0x40A9 +#define CL_APPLE_SETMEMOBJECTDESTRUCTOR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/********************************* -* cl_qcom_ion_host_ptr extension -*********************************/ +typedef cl_int CL_API_CALL +clSetMemObjectDestructorAPPLE_t( + cl_mem memobj, + void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), + void* user_data); -#define CL_MEM_ION_HOST_PTR_QCOM 0x40A8 +typedef clSetMemObjectDestructorAPPLE_t * +clSetMemObjectDestructorAPPLE_fn CL_API_SUFFIX__VERSION_1_0; -typedef struct _cl_mem_ion_host_ptr -{ - /* Type of external memory allocation. */ - /* Must be CL_MEM_ION_HOST_PTR_QCOM for ION allocations. */ - cl_mem_ext_host_ptr ext_host_ptr; +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) - /* ION file descriptor */ - int ion_filedesc; +extern CL_API_ENTRY cl_int CL_API_CALL +clSetMemObjectDestructorAPPLE( + cl_mem memobj, + void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), + void* user_data) CL_API_SUFFIX__VERSION_1_0; - /* Host pointer to the ION allocated memory */ - void* ion_hostptr; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -} cl_mem_ion_host_ptr; +/*************************************************************** +* cl_APPLE_ContextLoggingFunctions +***************************************************************/ +#define cl_APPLE_ContextLoggingFunctions 1 +#define CL_APPLE_CONTEXTLOGGINGFUNCTIONS_EXTENSION_NAME \ + "cl_APPLE_ContextLoggingFunctions" -/********************************* -* cl_qcom_android_native_buffer_host_ptr extension -*********************************/ +#define CL_APPLE_CONTEXTLOGGINGFUNCTIONS_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -#define CL_MEM_ANDROID_NATIVE_BUFFER_HOST_PTR_QCOM 0x40C6 -typedef struct _cl_mem_android_native_buffer_host_ptr -{ - /* Type of external memory allocation. */ - /* Must be CL_MEM_ANDROID_NATIVE_BUFFER_HOST_PTR_QCOM for Android native buffers. */ - cl_mem_ext_host_ptr ext_host_ptr; +typedef void CL_API_CALL +clLogMessagesToSystemLogAPPLE_t( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data); - /* Virtual pointer to the android native buffer */ - void* anb_ptr; +typedef clLogMessagesToSystemLogAPPLE_t * +clLogMessagesToSystemLogAPPLE_fn CL_API_SUFFIX__VERSION_1_0; -} cl_mem_android_native_buffer_host_ptr; +typedef void CL_API_CALL +clLogMessagesToStdoutAPPLE_t( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data); +typedef clLogMessagesToStdoutAPPLE_t * +clLogMessagesToStdoutAPPLE_fn CL_API_SUFFIX__VERSION_1_0; -/****************************************** - * cl_img_yuv_image extension * - ******************************************/ +typedef void CL_API_CALL +clLogMessagesToStderrAPPLE_t( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data); -/* Image formats used in clCreateImage */ -#define CL_NV21_IMG 0x40D0 -#define CL_YV12_IMG 0x40D1 +typedef clLogMessagesToStderrAPPLE_t * +clLogMessagesToStderrAPPLE_fn CL_API_SUFFIX__VERSION_1_0; +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/****************************************** - * cl_img_cached_allocations extension * - ******************************************/ +extern CL_API_ENTRY void CL_API_CALL +clLogMessagesToSystemLogAPPLE( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data) CL_API_SUFFIX__VERSION_1_0; -/* Flag values used by clCreateBuffer */ -#define CL_MEM_USE_UNCACHED_CPU_MEMORY_IMG (1 << 26) -#define CL_MEM_USE_CACHED_CPU_MEMORY_IMG (1 << 27) +extern CL_API_ENTRY void CL_API_CALL +clLogMessagesToStdoutAPPLE( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data) CL_API_SUFFIX__VERSION_1_0; +extern CL_API_ENTRY void CL_API_CALL +clLogMessagesToStderrAPPLE( + const char* errstr, + const void* private_info, + size_t cb, + void* user_data) CL_API_SUFFIX__VERSION_1_0; -/****************************************** - * cl_img_use_gralloc_ptr extension * - ******************************************/ -#define cl_img_use_gralloc_ptr 1 +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/* Flag values used by clCreateBuffer */ -#define CL_MEM_USE_GRALLOC_PTR_IMG (1 << 28) +/*************************************************************** +* cl_khr_icd +***************************************************************/ +#define cl_khr_icd 1 +#define CL_KHR_ICD_EXTENSION_NAME \ + "cl_khr_icd" -/* To be used by clGetEventInfo: */ -#define CL_COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG 0x40D2 -#define CL_COMMAND_RELEASE_GRALLOC_OBJECTS_IMG 0x40D3 -/* Error codes from clEnqueueAcquireGrallocObjectsIMG and clEnqueueReleaseGrallocObjectsIMG */ -#define CL_GRALLOC_RESOURCE_NOT_ACQUIRED_IMG 0x40D4 -#define CL_INVALID_GRALLOC_OBJECT_IMG 0x40D5 +#define CL_KHR_ICD_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueAcquireGrallocObjectsIMG(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +/* cl_platform_info */ +#define CL_PLATFORM_ICD_SUFFIX_KHR 0x0920 -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueReleaseGrallocObjectsIMG(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +/* Error codes */ +#define CL_PLATFORM_NOT_FOUND_KHR -1001 -/****************************************** - * cl_img_generate_mipmap extension * - ******************************************/ -#define cl_img_generate_mipmap 1 -typedef cl_uint cl_mipmap_filter_mode_img; +typedef cl_int CL_API_CALL +clIcdGetPlatformIDsKHR_t( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms); -/* To be used by clEnqueueGenerateMipmapIMG */ -#define CL_MIPMAP_FILTER_ANY_IMG 0x0 -#define CL_MIPMAP_FILTER_BOX_IMG 0x1 +typedef clIcdGetPlatformIDsKHR_t * +clIcdGetPlatformIDsKHR_fn ; -/* To be used by clGetEventInfo */ -#define CL_COMMAND_GENERATE_MIPMAP_IMG 0x40D6 - -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueGenerateMipmapIMG(cl_command_queue command_queue, - cl_mem src_image, - cl_mem dst_image, - cl_mipmap_filter_mode_img mipmap_filter_mode, - const size_t *array_region, - const size_t *mip_region, - cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -/****************************************** - * cl_img_mem_properties extension * - ******************************************/ -#define cl_img_mem_properties 1 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/* To be used by clCreateBufferWithProperties */ -#define CL_MEM_ALLOC_FLAGS_IMG 0x40D7 +extern CL_API_ENTRY cl_int CL_API_CALL +clIcdGetPlatformIDsKHR( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms) ; -/* To be used wiith the CL_MEM_ALLOC_FLAGS_IMG property */ -typedef cl_bitfield cl_mem_alloc_flags_img; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/* To be used with cl_mem_alloc_flags_img */ -#define CL_MEM_ALLOC_RELAX_REQUIREMENTS_IMG (1 << 0) +/*************************************************************** +* cl_khr_il_program +***************************************************************/ +#define cl_khr_il_program 1 +#define CL_KHR_IL_PROGRAM_EXTENSION_NAME \ + "cl_khr_il_program" -/********************************* -* cl_khr_subgroups extension -*********************************/ -#define cl_khr_subgroups 1 -#if !defined(CL_VERSION_2_1) -/* For OpenCL 2.1 and newer, cl_kernel_sub_group_info is declared in CL.h. - In hindsight, there should have been a khr suffix on this type for - the extension, but keeping it un-suffixed to maintain backwards - compatibility. */ -typedef cl_uint cl_kernel_sub_group_info; -#endif +#define CL_KHR_IL_PROGRAM_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_kernel_sub_group_info */ -#define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR 0x2033 -#define CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR 0x2034 - -extern CL_API_ENTRY cl_int CL_API_CALL -clGetKernelSubGroupInfoKHR(cl_kernel in_kernel, - cl_device_id in_device, - cl_kernel_sub_group_info param_name, - size_t input_value_size, - const void * input_value, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_0_DEPRECATED; - -typedef cl_int -(CL_API_CALL * clGetKernelSubGroupInfoKHR_fn)(cl_kernel in_kernel, - cl_device_id in_device, - cl_kernel_sub_group_info param_name, - size_t input_value_size, - const void * input_value, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_2_0_DEPRECATED; - - -/********************************* -* cl_khr_mipmap_image extension -*********************************/ +/* cl_device_info */ +#define CL_DEVICE_IL_VERSION_KHR 0x105B -/* cl_sampler_properties */ -#define CL_SAMPLER_MIP_FILTER_MODE_KHR 0x1155 -#define CL_SAMPLER_LOD_MIN_KHR 0x1156 -#define CL_SAMPLER_LOD_MAX_KHR 0x1157 +/* cl_program_info */ +#define CL_PROGRAM_IL_KHR 0x1169 -/********************************* -* cl_khr_priority_hints extension -*********************************/ -/* This extension define is for backwards compatibility. - It shouldn't be required since this extension has no new functions. */ -#define cl_khr_priority_hints 1 +typedef cl_program CL_API_CALL +clCreateProgramWithILKHR_t( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret); -typedef cl_uint cl_queue_priority_khr; +typedef clCreateProgramWithILKHR_t * +clCreateProgramWithILKHR_fn CL_API_SUFFIX__VERSION_1_2; -/* cl_command_queue_properties */ -#define CL_QUEUE_PRIORITY_KHR 0x1096 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/* cl_queue_priority_khr */ -#define CL_QUEUE_PRIORITY_HIGH_KHR (1<<0) -#define CL_QUEUE_PRIORITY_MED_KHR (1<<1) -#define CL_QUEUE_PRIORITY_LOW_KHR (1<<2) +extern CL_API_ENTRY cl_program CL_API_CALL +clCreateProgramWithILKHR( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/********************************* -* cl_khr_throttle_hints extension -*********************************/ -/* This extension define is for backwards compatibility. - It shouldn't be required since this extension has no new functions. */ -#define cl_khr_throttle_hints 1 +/*************************************************************** +* cl_khr_image2d_from_buffer +***************************************************************/ +#define cl_khr_image2d_from_buffer 1 +#define CL_KHR_IMAGE2D_FROM_BUFFER_EXTENSION_NAME \ + "cl_khr_image2d_from_buffer" -typedef cl_uint cl_queue_throttle_khr; -/* cl_command_queue_properties */ -#define CL_QUEUE_THROTTLE_KHR 0x1097 +#define CL_KHR_IMAGE2D_FROM_BUFFER_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_queue_throttle_khr */ -#define CL_QUEUE_THROTTLE_HIGH_KHR (1<<0) -#define CL_QUEUE_THROTTLE_MED_KHR (1<<1) -#define CL_QUEUE_THROTTLE_LOW_KHR (1<<2) +/* cl_device_info */ +#define CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR 0x104A +#define CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR 0x104B +/*************************************************************** +* cl_khr_initialize_memory +***************************************************************/ +#define cl_khr_initialize_memory 1 +#define CL_KHR_INITIALIZE_MEMORY_EXTENSION_NAME \ + "cl_khr_initialize_memory" -/********************************* -* cl_khr_subgroup_named_barrier -*********************************/ -/* This extension define is for backwards compatibility. - It shouldn't be required since this extension has no new functions. */ -#define cl_khr_subgroup_named_barrier 1 -/* cl_device_info */ -#define CL_DEVICE_MAX_NAMED_BARRIER_COUNT_KHR 0x2035 +#define CL_KHR_INITIALIZE_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) +typedef cl_bitfield cl_context_memory_initialize_khr; -/********************************* -* cl_khr_extended_versioning -*********************************/ +/* cl_context_properties */ +#define CL_CONTEXT_MEMORY_INITIALIZE_KHR 0x2030 -#define cl_khr_extended_versioning 1 +/* cl_context_memory_initialize_khr */ +#define CL_CONTEXT_MEMORY_INITIALIZE_LOCAL_KHR (1 << 0) +#define CL_CONTEXT_MEMORY_INITIALIZE_PRIVATE_KHR (1 << 1) -#define CL_VERSION_MAJOR_BITS_KHR (10) -#define CL_VERSION_MINOR_BITS_KHR (10) -#define CL_VERSION_PATCH_BITS_KHR (12) +/*************************************************************** +* cl_khr_terminate_context +***************************************************************/ +#define cl_khr_terminate_context 1 +#define CL_KHR_TERMINATE_CONTEXT_EXTENSION_NAME \ + "cl_khr_terminate_context" -#define CL_VERSION_MAJOR_MASK_KHR ((1 << CL_VERSION_MAJOR_BITS_KHR) - 1) -#define CL_VERSION_MINOR_MASK_KHR ((1 << CL_VERSION_MINOR_BITS_KHR) - 1) -#define CL_VERSION_PATCH_MASK_KHR ((1 << CL_VERSION_PATCH_BITS_KHR) - 1) -#define CL_VERSION_MAJOR_KHR(version) ((version) >> (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) -#define CL_VERSION_MINOR_KHR(version) (((version) >> CL_VERSION_PATCH_BITS_KHR) & CL_VERSION_MINOR_MASK_KHR) -#define CL_VERSION_PATCH_KHR(version) ((version) & CL_VERSION_PATCH_MASK_KHR) +#define CL_KHR_TERMINATE_CONTEXT_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -#define CL_MAKE_VERSION_KHR(major, minor, patch) \ - ((((major) & CL_VERSION_MAJOR_MASK_KHR) << (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) | \ - (((minor) & CL_VERSION_MINOR_MASK_KHR) << CL_VERSION_PATCH_BITS_KHR) | \ - ((patch) & CL_VERSION_PATCH_MASK_KHR)) +typedef cl_bitfield cl_device_terminate_capability_khr; -typedef cl_uint cl_version_khr; +/* cl_device_info */ +#define CL_DEVICE_TERMINATE_CAPABILITY_KHR 0x2031 -#define CL_NAME_VERSION_MAX_NAME_SIZE_KHR 64 +/* cl_context_properties */ +#define CL_CONTEXT_TERMINATE_KHR 0x2032 -typedef struct _cl_name_version_khr -{ - cl_version_khr version; - char name[CL_NAME_VERSION_MAX_NAME_SIZE_KHR]; -} cl_name_version_khr; +/* cl_device_terminate_capability_khr */ +#define CL_DEVICE_TERMINATE_CAPABILITY_CONTEXT_KHR (1 << 0) -/* cl_platform_info */ -#define CL_PLATFORM_NUMERIC_VERSION_KHR 0x0906 -#define CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR 0x0907 +/* Error codes */ +#define CL_CONTEXT_TERMINATED_KHR -1121 -/* cl_device_info */ -#define CL_DEVICE_NUMERIC_VERSION_KHR 0x105E -#define CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR 0x105F -#define CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR 0x1060 -#define CL_DEVICE_ILS_WITH_VERSION_KHR 0x1061 -#define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR 0x1062 +typedef cl_int CL_API_CALL +clTerminateContextKHR_t( + cl_context context); -/********************************* -* cl_khr_device_uuid extension -*********************************/ -#define cl_khr_device_uuid 1 +typedef clTerminateContextKHR_t * +clTerminateContextKHR_fn CL_API_SUFFIX__VERSION_1_2; -#define CL_UUID_SIZE_KHR 16 -#define CL_LUID_SIZE_KHR 8 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -#define CL_DEVICE_UUID_KHR 0x106A -#define CL_DRIVER_UUID_KHR 0x106B -#define CL_DEVICE_LUID_VALID_KHR 0x106C -#define CL_DEVICE_LUID_KHR 0x106D -#define CL_DEVICE_NODE_MASK_KHR 0x106E +extern CL_API_ENTRY cl_int CL_API_CALL +clTerminateContextKHR( + cl_context context) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** -* cl_khr_pci_bus_info +* cl_khr_spir ***************************************************************/ -#define cl_khr_pci_bus_info 1 +#define cl_khr_spir 1 +#define CL_KHR_SPIR_EXTENSION_NAME \ + "cl_khr_spir" -typedef struct _cl_device_pci_bus_info_khr { - cl_uint pci_domain; - cl_uint pci_bus; - cl_uint pci_device; - cl_uint pci_function; -} cl_device_pci_bus_info_khr; + +#define CL_KHR_SPIR_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /* cl_device_info */ -#define CL_DEVICE_PCI_BUS_INFO_KHR 0x410F +#define CL_DEVICE_SPIR_VERSIONS 0x40E0 +/* cl_program_binary_type */ +#define CL_PROGRAM_BINARY_TYPE_INTERMEDIATE 0x40E1 /*************************************************************** -* cl_khr_suggested_local_work_size +* cl_khr_create_command_queue ***************************************************************/ -#define cl_khr_suggested_local_work_size 1 +#define cl_khr_create_command_queue 1 +#define CL_KHR_CREATE_COMMAND_QUEUE_EXTENSION_NAME \ + "cl_khr_create_command_queue" -extern CL_API_ENTRY cl_int CL_API_CALL -clGetKernelSuggestedLocalWorkSizeKHR( - cl_command_queue command_queue, - cl_kernel kernel, - cl_uint work_dim, - const size_t* global_work_offset, - const size_t* global_work_size, - size_t* suggested_local_work_size) CL_API_SUFFIX__VERSION_3_0; -typedef cl_int (CL_API_CALL * -clGetKernelSuggestedLocalWorkSizeKHR_fn)( - cl_command_queue command_queue, - cl_kernel kernel, - cl_uint work_dim, - const size_t* global_work_offset, - const size_t* global_work_size, - size_t* suggested_local_work_size) CL_API_SUFFIX__VERSION_3_0; +#define CL_KHR_CREATE_COMMAND_QUEUE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_properties cl_queue_properties_khr; +typedef cl_command_queue CL_API_CALL +clCreateCommandQueueWithPropertiesKHR_t( + cl_context context, + cl_device_id device, + const cl_queue_properties_khr* properties, + cl_int* errcode_ret); + +typedef clCreateCommandQueueWithPropertiesKHR_t * +clCreateCommandQueueWithPropertiesKHR_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_command_queue CL_API_CALL +clCreateCommandQueueWithPropertiesKHR( + cl_context context, + cl_device_id device, + const cl_queue_properties_khr* properties, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + /*************************************************************** -* cl_khr_integer_dot_product +* cl_nv_device_attribute_query ***************************************************************/ -#define cl_khr_integer_dot_product 1 +#define cl_nv_device_attribute_query 1 +#define CL_NV_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ + "cl_nv_device_attribute_query" -typedef cl_bitfield cl_device_integer_dot_product_capabilities_khr; -/* cl_device_integer_dot_product_capabilities_khr */ -#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR (1 << 0) -#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR (1 << 1) +#define CL_NV_DEVICE_ATTRIBUTE_QUERY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV 0x4000 +#define CL_DEVICE_COMPUTE_CAPABILITY_MINOR_NV 0x4001 +#define CL_DEVICE_REGISTERS_PER_BLOCK_NV 0x4002 +#define CL_DEVICE_WARP_SIZE_NV 0x4003 +#define CL_DEVICE_GPU_OVERLAP_NV 0x4004 +#define CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV 0x4005 +#define CL_DEVICE_INTEGRATED_MEMORY_NV 0x4006 + +/*************************************************************** +* cl_amd_device_attribute_query +***************************************************************/ +#define cl_amd_device_attribute_query 1 +#define CL_AMD_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ + "cl_amd_device_attribute_query" -typedef struct _cl_device_integer_dot_product_acceleration_properties_khr { - cl_bool signed_accelerated; - cl_bool unsigned_accelerated; - cl_bool mixed_signedness_accelerated; - cl_bool accumulating_saturating_signed_accelerated; - cl_bool accumulating_saturating_unsigned_accelerated; - cl_bool accumulating_saturating_mixed_signedness_accelerated; -} cl_device_integer_dot_product_acceleration_properties_khr; + +#define CL_AMD_DEVICE_ATTRIBUTE_QUERY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* cl_device_info */ -#define CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR 0x1073 -#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR 0x1074 -#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR 0x1075 +#define CL_DEVICE_PROFILING_TIMER_OFFSET_AMD 0x4036 +#define CL_DEVICE_TOPOLOGY_AMD 0x4037 +#define CL_DEVICE_BOARD_NAME_AMD 0x4038 +#define CL_DEVICE_GLOBAL_FREE_MEMORY_AMD 0x4039 +#define CL_DEVICE_SIMD_PER_COMPUTE_UNIT_AMD 0x4040 +#define CL_DEVICE_SIMD_WIDTH_AMD 0x4041 +#define CL_DEVICE_SIMD_INSTRUCTION_WIDTH_AMD 0x4042 +#define CL_DEVICE_WAVEFRONT_WIDTH_AMD 0x4043 +#define CL_DEVICE_GLOBAL_MEM_CHANNELS_AMD 0x4044 +#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANKS_AMD 0x4045 +#define CL_DEVICE_GLOBAL_MEM_CHANNEL_BANK_WIDTH_AMD 0x4046 +#define CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD 0x4047 +#define CL_DEVICE_LOCAL_MEM_BANKS_AMD 0x4048 +#define CL_DEVICE_THREAD_TRACE_SUPPORTED_AMD 0x4049 +#define CL_DEVICE_GFXIP_MAJOR_AMD 0x404A +#define CL_DEVICE_GFXIP_MINOR_AMD 0x404B +#define CL_DEVICE_AVAILABLE_ASYNC_QUEUES_AMD 0x404C +#define CL_DEVICE_PREFERRED_WORK_GROUP_SIZE_AMD 0x4030 +#define CL_DEVICE_MAX_WORK_GROUP_SIZE_AMD 0x4031 +#define CL_DEVICE_PREFERRED_CONSTANT_BUFFER_SIZE_AMD 0x4033 +#define CL_DEVICE_PCIE_ID_AMD 0x4034 +/*************************************************************** +* cl_arm_printf +***************************************************************/ +#define cl_arm_printf 1 +#define CL_ARM_PRINTF_EXTENSION_NAME \ + "cl_arm_printf" + + +#define CL_ARM_PRINTF_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_context_properties */ +#define CL_PRINTF_CALLBACK_ARM 0x40B0 +#define CL_PRINTF_BUFFERSIZE_ARM 0x40B1 /*************************************************************** -* cl_khr_external_memory +* cl_ext_device_fission ***************************************************************/ -#define cl_khr_external_memory 1 +#define cl_ext_device_fission 1 +#define CL_EXT_DEVICE_FISSION_EXTENSION_NAME \ + "cl_ext_device_fission" -typedef cl_uint cl_external_memory_handle_type_khr; -/* cl_platform_info */ -#define CL_PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x2044 +#define CL_EXT_DEVICE_FISSION_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_ulong cl_device_partition_property_ext; + +/* Error codes */ +#define CL_DEVICE_PARTITION_FAILED_EXT -1057 +#define CL_INVALID_PARTITION_COUNT_EXT -1058 +#define CL_INVALID_PARTITION_NAME_EXT -1059 /* cl_device_info */ -#define CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x204F +#define CL_DEVICE_PARENT_DEVICE_EXT 0x4054 +#define CL_DEVICE_PARTITION_TYPES_EXT 0x4055 +#define CL_DEVICE_AFFINITY_DOMAINS_EXT 0x4056 +#define CL_DEVICE_REFERENCE_COUNT_EXT 0x4057 +#define CL_DEVICE_PARTITION_STYLE_EXT 0x4058 -/* cl_mem_properties */ -#define CL_DEVICE_HANDLE_LIST_KHR 0x2051 -#define CL_DEVICE_HANDLE_LIST_END_KHR 0 +/* cl_device_partition_property_ext */ +#define CL_DEVICE_PARTITION_EQUALLY_EXT 0x4050 +#define CL_DEVICE_PARTITION_BY_COUNTS_EXT 0x4051 +#define CL_DEVICE_PARTITION_BY_NAMES_EXT 0x4052 +#define CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT 0x4053 -/* cl_command_type */ -#define CL_COMMAND_ACQUIRE_EXTERNAL_MEM_OBJECTS_KHR 0x2047 -#define CL_COMMAND_RELEASE_EXTERNAL_MEM_OBJECTS_KHR 0x2048 +/* cl_device_partition_property_ext - affinity domains */ +#define CL_AFFINITY_DOMAIN_L1_CACHE_EXT 0x1 +#define CL_AFFINITY_DOMAIN_L2_CACHE_EXT 0x2 +#define CL_AFFINITY_DOMAIN_L3_CACHE_EXT 0x3 +#define CL_AFFINITY_DOMAIN_L4_CACHE_EXT 0x4 +#define CL_AFFINITY_DOMAIN_NUMA_EXT 0x10 +#define CL_AFFINITY_DOMAIN_NEXT_FISSIONABLE_EXT 0x100 +/* cl_device_partition_property_ext - list terminators */ +#define CL_PROPERTIES_LIST_END_EXT ((cl_device_partition_property_ext)0) +#define CL_PARTITION_BY_COUNTS_LIST_END_EXT ((cl_device_partition_property_ext)0) +#define CL_PARTITION_BY_NAMES_LIST_END_EXT ((cl_device_partition_property_ext)0 - 1) -typedef cl_int (CL_API_CALL * -clEnqueueAcquireExternalMemObjectsKHR_fn)( - cl_command_queue command_queue, - cl_uint num_mem_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_3_0; -typedef cl_int (CL_API_CALL * -clEnqueueReleaseExternalMemObjectsKHR_fn)( - cl_command_queue command_queue, - cl_uint num_mem_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_3_0; +typedef cl_int CL_API_CALL +clReleaseDeviceEXT_t( + cl_device_id device); + +typedef clReleaseDeviceEXT_t * +clReleaseDeviceEXT_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL +clRetainDeviceEXT_t( + cl_device_id device); + +typedef clRetainDeviceEXT_t * +clRetainDeviceEXT_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL +clCreateSubDevicesEXT_t( + cl_device_id in_device, + const cl_device_partition_property_ext* properties, + cl_uint num_entries, + cl_device_id* out_devices, + cl_uint* num_devices); + +typedef clCreateSubDevicesEXT_t * +clCreateSubDevicesEXT_fn CL_API_SUFFIX__VERSION_1_1; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueAcquireExternalMemObjectsKHR( +clReleaseDeviceEXT( + cl_device_id device) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainDeviceEXT( + cl_device_id device) CL_API_SUFFIX__VERSION_1_1; + +extern CL_API_ENTRY cl_int CL_API_CALL +clCreateSubDevicesEXT( + cl_device_id in_device, + const cl_device_partition_property_ext* properties, + cl_uint num_entries, + cl_device_id* out_devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_1; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_ext_migrate_memobject +***************************************************************/ +#define cl_ext_migrate_memobject 1 +#define CL_EXT_MIGRATE_MEMOBJECT_EXTENSION_NAME \ + "cl_ext_migrate_memobject" + + +#define CL_EXT_MIGRATE_MEMOBJECT_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_bitfield cl_mem_migration_flags_ext; + +/* cl_mem_migration_flags_ext */ +#define CL_MIGRATE_MEM_OBJECT_HOST_EXT (1 << 0) + +/* cl_command_type */ +#define CL_COMMAND_MIGRATE_MEM_OBJECT_EXT 0x4040 + + +typedef cl_int CL_API_CALL +clEnqueueMigrateMemObjectEXT_t( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, + cl_mem_migration_flags_ext flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_3_0; + cl_event* event); + +typedef clEnqueueMigrateMemObjectEXT_t * +clEnqueueMigrateMemObjectEXT_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueReleaseExternalMemObjectsKHR( +clEnqueueMigrateMemObjectEXT( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, + cl_mem_migration_flags_ext flags, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_3_0; - -/*************************************************************** -* cl_khr_external_memory_dma_buf -***************************************************************/ -#define cl_khr_external_memory_dma_buf 1 + cl_event* event) ; -/* cl_external_memory_handle_type_khr */ -#define CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR 0x2067 +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** -* cl_khr_external_memory_dx +* cl_ext_cxx_for_opencl ***************************************************************/ -#define cl_khr_external_memory_dx 1 +#define cl_ext_cxx_for_opencl 1 +#define CL_EXT_CXX_FOR_OPENCL_EXTENSION_NAME \ + "cl_ext_cxx_for_opencl" -/* cl_external_memory_handle_type_khr */ -#define CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KHR 0x2063 -#define CL_EXTERNAL_MEMORY_HANDLE_D3D11_TEXTURE_KMT_KHR 0x2064 -#define CL_EXTERNAL_MEMORY_HANDLE_D3D12_HEAP_KHR 0x2065 -#define CL_EXTERNAL_MEMORY_HANDLE_D3D12_RESOURCE_KHR 0x2066 -/*************************************************************** -* cl_khr_external_memory_opaque_fd -***************************************************************/ -#define cl_khr_external_memory_opaque_fd 1 +#define CL_EXT_CXX_FOR_OPENCL_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_external_memory_handle_type_khr */ -#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR 0x2060 +/* cl_device_info */ +#define CL_DEVICE_CXX_FOR_OPENCL_NUMERIC_VERSION_EXT 0x4230 /*************************************************************** -* cl_khr_external_memory_win32 +* cl_qcom_ext_host_ptr ***************************************************************/ -#define cl_khr_external_memory_win32 1 +#define cl_qcom_ext_host_ptr 1 +#define CL_QCOM_EXT_HOST_PTR_EXTENSION_NAME \ + "cl_qcom_ext_host_ptr" -/* cl_external_memory_handle_type_khr */ -#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR 0x2061 -#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2062 -/*************************************************************** -* cl_khr_external_semaphore -***************************************************************/ -#define cl_khr_external_semaphore 1 +#define CL_QCOM_EXT_HOST_PTR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -typedef struct _cl_semaphore_khr * cl_semaphore_khr; -typedef cl_uint cl_external_semaphore_handle_type_khr; +typedef cl_uint cl_image_pitch_info_qcom; +typedef struct _cl_mem_ext_host_ptr { + cl_uint allocation_type; + cl_uint host_cache_policy; +} cl_mem_ext_host_ptr; -/* cl_platform_info */ -#define CL_PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x2037 -#define CL_PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x2038 +/* cl_mem_flags */ +#define CL_MEM_EXT_HOST_PTR_QCOM (1 << 29) /* cl_device_info */ -#define CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x204D -#define CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x204E +#define CL_DEVICE_EXT_MEM_PADDING_IN_BYTES_QCOM 0x40A0 +#define CL_DEVICE_PAGE_SIZE_QCOM 0x40A1 -/* cl_semaphore_properties_khr */ -#define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x203F -#define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR 0 +/* cl_image_pitch_info_qcom */ +#define CL_IMAGE_ROW_ALIGNMENT_QCOM 0x40A2 +#define CL_IMAGE_SLICE_ALIGNMENT_QCOM 0x40A3 +/* cl_uint host_cache_policy */ +#define CL_MEM_HOST_UNCACHED_QCOM 0x40A4 +#define CL_MEM_HOST_WRITEBACK_QCOM 0x40A5 +#define CL_MEM_HOST_WRITETHROUGH_QCOM 0x40A6 +#define CL_MEM_HOST_WRITE_COMBINING_QCOM 0x40A7 -typedef cl_int (CL_API_CALL * -clGetSemaphoreHandleForTypeKHR_fn)( - cl_semaphore_khr sema_object, + +typedef cl_int CL_API_CALL +clGetDeviceImageInfoQCOM_t( cl_device_id device, - cl_external_semaphore_handle_type_khr handle_type, - size_t handle_size, - void* handle_ptr, - size_t* handle_size_ret) CL_API_SUFFIX__VERSION_1_2; + size_t image_width, + size_t image_height, + const cl_image_format* image_format, + cl_image_pitch_info_qcom param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetDeviceImageInfoQCOM_t * +clGetDeviceImageInfoQCOM_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clGetSemaphoreHandleForTypeKHR( - cl_semaphore_khr sema_object, +clGetDeviceImageInfoQCOM( cl_device_id device, - cl_external_semaphore_handle_type_khr handle_type, - size_t handle_size, - void* handle_ptr, - size_t* handle_size_ret) CL_API_SUFFIX__VERSION_1_2; + size_t image_width, + size_t image_height, + const cl_image_format* image_format, + cl_image_pitch_info_qcom param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ /*************************************************************** -* cl_khr_external_semaphore_dx_fence +* cl_qcom_ext_host_ptr_iocoherent ***************************************************************/ -#define cl_khr_external_semaphore_dx_fence 1 +#define cl_qcom_ext_host_ptr_iocoherent 1 +#define CL_QCOM_EXT_HOST_PTR_IOCOHERENT_EXTENSION_NAME \ + "cl_qcom_ext_host_ptr_iocoherent" -/* cl_external_semaphore_handle_type_khr */ -#define CL_SEMAPHORE_HANDLE_D3D12_FENCE_KHR 0x2059 + +#define CL_QCOM_EXT_HOST_PTR_IOCOHERENT_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_uint host_cache_policy */ +#define CL_MEM_HOST_IOCOHERENT_QCOM 0x40A9 /*************************************************************** -* cl_khr_external_semaphore_opaque_fd +* cl_qcom_ion_host_ptr ***************************************************************/ -#define cl_khr_external_semaphore_opaque_fd 1 +#define cl_qcom_ion_host_ptr 1 +#define CL_QCOM_ION_HOST_PTR_EXTENSION_NAME \ + "cl_qcom_ion_host_ptr" -/* cl_external_semaphore_handle_type_khr */ -#define CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR 0x2055 + +#define CL_QCOM_ION_HOST_PTR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* type cl_mem_ext_host_ptr */ +typedef struct _cl_mem_ion_host_ptr { + cl_mem_ext_host_ptr ext_host_ptr; + int ion_filedesc; + void* ion_hostptr; +} cl_mem_ion_host_ptr; + +/* cl_uint allocation_type */ +#define CL_MEM_ION_HOST_PTR_QCOM 0x40A8 /*************************************************************** -* cl_khr_external_semaphore_sync_fd +* cl_qcom_android_native_buffer_host_ptr ***************************************************************/ -#define cl_khr_external_semaphore_sync_fd 1 +#define cl_qcom_android_native_buffer_host_ptr 1 +#define CL_QCOM_ANDROID_NATIVE_BUFFER_HOST_PTR_EXTENSION_NAME \ + "cl_qcom_android_native_buffer_host_ptr" -/* cl_external_semaphore_handle_type_khr */ -#define CL_SEMAPHORE_HANDLE_SYNC_FD_KHR 0x2058 + +#define CL_QCOM_ANDROID_NATIVE_BUFFER_HOST_PTR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* type cl_mem_ext_host_ptr */ +typedef struct _cl_mem_android_native_buffer_host_ptr { + cl_mem_ext_host_ptr ext_host_ptr; + void* anb_ptr; +} cl_mem_android_native_buffer_host_ptr; + +/* cl_uint allocation_type */ +#define CL_MEM_ANDROID_NATIVE_BUFFER_HOST_PTR_QCOM 0x40C6 /*************************************************************** -* cl_khr_external_semaphore_win32 +* cl_img_yuv_image ***************************************************************/ -#define cl_khr_external_semaphore_win32 1 +#define cl_img_yuv_image 1 +#define CL_IMG_YUV_IMAGE_EXTENSION_NAME \ + "cl_img_yuv_image" -/* cl_external_semaphore_handle_type_khr */ -#define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR 0x2056 -#define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2057 + +#define CL_IMG_YUV_IMAGE_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_channel_order */ +#define CL_NV21_IMG 0x40D0 +#define CL_YV12_IMG 0x40D1 /*************************************************************** -* cl_khr_semaphore +* cl_img_cached_allocations ***************************************************************/ -#define cl_khr_semaphore 1 - -/* type cl_semaphore_khr */ -typedef cl_properties cl_semaphore_properties_khr; -typedef cl_uint cl_semaphore_info_khr; -typedef cl_uint cl_semaphore_type_khr; -typedef cl_ulong cl_semaphore_payload_khr; +#define cl_img_cached_allocations 1 +#define CL_IMG_CACHED_ALLOCATIONS_EXTENSION_NAME \ + "cl_img_cached_allocations" -/* cl_semaphore_type */ -#define CL_SEMAPHORE_TYPE_BINARY_KHR 1 -/* cl_platform_info */ -#define CL_PLATFORM_SEMAPHORE_TYPES_KHR 0x2036 +#define CL_IMG_CACHED_ALLOCATIONS_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/* cl_device_info */ -#define CL_DEVICE_SEMAPHORE_TYPES_KHR 0x204C +/* cl_mem_flags */ +#define CL_MEM_USE_UNCACHED_CPU_MEMORY_IMG (1 << 26) +#define CL_MEM_USE_CACHED_CPU_MEMORY_IMG (1 << 27) -/* cl_semaphore_info_khr */ -#define CL_SEMAPHORE_CONTEXT_KHR 0x2039 -#define CL_SEMAPHORE_REFERENCE_COUNT_KHR 0x203A -#define CL_SEMAPHORE_PROPERTIES_KHR 0x203B -#define CL_SEMAPHORE_PAYLOAD_KHR 0x203C +/*************************************************************** +* cl_img_use_gralloc_ptr +***************************************************************/ +#define cl_img_use_gralloc_ptr 1 +#define CL_IMG_USE_GRALLOC_PTR_EXTENSION_NAME \ + "cl_img_use_gralloc_ptr" -/* cl_semaphore_info_khr or cl_semaphore_properties_khr */ -#define CL_SEMAPHORE_TYPE_KHR 0x203D -/* enum CL_DEVICE_HANDLE_LIST_KHR */ -/* enum CL_DEVICE_HANDLE_LIST_END_KHR */ -/* cl_command_type */ -#define CL_COMMAND_SEMAPHORE_WAIT_KHR 0x2042 -#define CL_COMMAND_SEMAPHORE_SIGNAL_KHR 0x2043 +#define CL_IMG_USE_GRALLOC_PTR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* Error codes */ -#define CL_INVALID_SEMAPHORE_KHR -1142 +#define CL_GRALLOC_RESOURCE_NOT_ACQUIRED_IMG 0x40D4 +#define CL_INVALID_GRALLOC_OBJECT_IMG 0x40D5 +/* cl_mem_flags */ +#define CL_MEM_USE_GRALLOC_PTR_IMG (1 << 28) + +/* cl_command_type */ +#define CL_COMMAND_ACQUIRE_GRALLOC_OBJECTS_IMG 0x40D2 +#define CL_COMMAND_RELEASE_GRALLOC_OBJECTS_IMG 0x40D3 -typedef cl_semaphore_khr (CL_API_CALL * -clCreateSemaphoreWithPropertiesKHR_fn)( - cl_context context, - const cl_semaphore_properties_khr* sema_props, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; -typedef cl_int (CL_API_CALL * -clEnqueueWaitSemaphoresKHR_fn)( +typedef cl_int CL_API_CALL +clEnqueueAcquireGrallocObjectsIMG_t( cl_command_queue command_queue, - cl_uint num_sema_objects, - const cl_semaphore_khr* sema_objects, - const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; + cl_event* event); + +typedef clEnqueueAcquireGrallocObjectsIMG_t * +clEnqueueAcquireGrallocObjectsIMG_fn CL_API_SUFFIX__VERSION_1_2; -typedef cl_int (CL_API_CALL * -clEnqueueSignalSemaphoresKHR_fn)( +typedef cl_int CL_API_CALL +clEnqueueReleaseGrallocObjectsIMG_t( cl_command_queue command_queue, - cl_uint num_sema_objects, - const cl_semaphore_khr* sema_objects, - const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL * -clGetSemaphoreInfoKHR_fn)( - cl_semaphore_khr sema_object, - cl_semaphore_info_khr param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL * -clReleaseSemaphoreKHR_fn)( - cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; + cl_event* event); -typedef cl_int (CL_API_CALL * -clRetainSemaphoreKHR_fn)( - cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; +typedef clEnqueueReleaseGrallocObjectsIMG_t * +clEnqueueReleaseGrallocObjectsIMG_fn CL_API_SUFFIX__VERSION_1_2; -extern CL_API_ENTRY cl_semaphore_khr CL_API_CALL -clCreateSemaphoreWithPropertiesKHR( - cl_context context, - const cl_semaphore_properties_khr* sema_props, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueWaitSemaphoresKHR( +clEnqueueAcquireGrallocObjectsIMG( cl_command_queue command_queue, - cl_uint num_sema_objects, - const cl_semaphore_khr* sema_objects, - const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSignalSemaphoresKHR( +clEnqueueReleaseGrallocObjectsIMG( cl_command_queue command_queue, - cl_uint num_sema_objects, - const cl_semaphore_khr* sema_objects, - const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_objects, + const cl_mem* mem_objects, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event) CL_API_SUFFIX__VERSION_1_2; -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSemaphoreInfoKHR( - cl_semaphore_khr sema_object, - cl_semaphore_info_khr param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; - -extern CL_API_ENTRY cl_int CL_API_CALL -clReleaseSemaphoreKHR( - cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; - -extern CL_API_ENTRY cl_int CL_API_CALL -clRetainSemaphoreKHR( - cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/********************************** - * cl_arm_import_memory extension * - **********************************/ -#define cl_arm_import_memory 1 +/*************************************************************** +* cl_img_generate_mipmap +***************************************************************/ +#define cl_img_generate_mipmap 1 +#define CL_IMG_GENERATE_MIPMAP_EXTENSION_NAME \ + "cl_img_generate_mipmap" -typedef intptr_t cl_import_properties_arm; -/* Default and valid proporties name for cl_arm_import_memory */ -#define CL_IMPORT_TYPE_ARM 0x40B2 +#define CL_IMG_GENERATE_MIPMAP_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/* Host process memory type default value for CL_IMPORT_TYPE_ARM property */ -#define CL_IMPORT_TYPE_HOST_ARM 0x40B3 +typedef cl_uint cl_mipmap_filter_mode_img; -/* DMA BUF memory type value for CL_IMPORT_TYPE_ARM property */ -#define CL_IMPORT_TYPE_DMA_BUF_ARM 0x40B4 +/* cl_mipmap_filter_mode_img */ +#define CL_MIPMAP_FILTER_ANY_IMG 0x0 +#define CL_MIPMAP_FILTER_BOX_IMG 0x1 -/* Protected memory property */ -#define CL_IMPORT_TYPE_PROTECTED_ARM 0x40B5 +/* cl_command_type */ +#define CL_COMMAND_GENERATE_MIPMAP_IMG 0x40D6 -/* Android hardware buffer type value for CL_IMPORT_TYPE_ARM property */ -#define CL_IMPORT_TYPE_ANDROID_HARDWARE_BUFFER_ARM 0x41E2 -/* Data consistency with host property */ -#define CL_IMPORT_DMA_BUF_DATA_CONSISTENCY_WITH_HOST_ARM 0x41E3 +typedef cl_int CL_API_CALL +clEnqueueGenerateMipmapIMG_t( + cl_command_queue command_queue, + cl_mem src_image, + cl_mem dst_image, + cl_mipmap_filter_mode_img mipmap_filter_mode, + const size_t* array_region, + const size_t* mip_region, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -/* Index of plane in a multiplanar hardware buffer */ -#define CL_IMPORT_ANDROID_HARDWARE_BUFFER_PLANE_INDEX_ARM 0x41EF +typedef clEnqueueGenerateMipmapIMG_t * +clEnqueueGenerateMipmapIMG_fn CL_API_SUFFIX__VERSION_1_2; -/* Index of layer in a multilayer hardware buffer */ -#define CL_IMPORT_ANDROID_HARDWARE_BUFFER_LAYER_INDEX_ARM 0x41F0 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -/* Import memory size value to indicate a size for the whole buffer */ -#define CL_IMPORT_MEMORY_WHOLE_ALLOCATION_ARM SIZE_MAX - -/* This extension adds a new function that allows for direct memory import into - * OpenCL via the clImportMemoryARM function. - * - * Memory imported through this interface will be mapped into the device's page - * tables directly, providing zero copy access. It will never fall back to copy - * operations and aliased buffers. - * - * Types of memory supported for import are specified as additional extension - * strings. - * - * This extension produces cl_mem allocations which are compatible with all other - * users of cl_mem in the standard API. - * - * This extension maps pages with the same properties as the normal buffer creation - * function clCreateBuffer. - */ -extern CL_API_ENTRY cl_mem CL_API_CALL -clImportMemoryARM( cl_context context, - cl_mem_flags flags, - const cl_import_properties_arm *properties, - void *memory, - size_t size, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueGenerateMipmapIMG( + cl_command_queue command_queue, + cl_mem src_image, + cl_mem dst_image, + cl_mipmap_filter_mode_img mipmap_filter_mode, + const size_t* array_region, + const size_t* mip_region, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/****************************************** - * cl_arm_shared_virtual_memory extension * - ******************************************/ -#define cl_arm_shared_virtual_memory 1 +/*************************************************************** +* cl_img_mem_properties +***************************************************************/ +#define cl_img_mem_properties 1 +#define CL_IMG_MEM_PROPERTIES_EXTENSION_NAME \ + "cl_img_mem_properties" -/* Used by clGetDeviceInfo */ -#define CL_DEVICE_SVM_CAPABILITIES_ARM 0x40B6 -/* Used by clGetMemObjectInfo */ -#define CL_MEM_USES_SVM_POINTER_ARM 0x40B7 +#define CL_IMG_MEM_PROPERTIES_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/* Used by clSetKernelExecInfoARM: */ -#define CL_KERNEL_EXEC_INFO_SVM_PTRS_ARM 0x40B8 -#define CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM 0x40B9 +/* cl_mem_properties */ +#define CL_MEM_ALLOC_FLAGS_IMG 0x40D7 -/* To be used by clGetEventInfo: */ -#define CL_COMMAND_SVM_FREE_ARM 0x40BA -#define CL_COMMAND_SVM_MEMCPY_ARM 0x40BB -#define CL_COMMAND_SVM_MEMFILL_ARM 0x40BC -#define CL_COMMAND_SVM_MAP_ARM 0x40BD -#define CL_COMMAND_SVM_UNMAP_ARM 0x40BE +/* cl_mem_alloc_flags_img */ +#define CL_MEM_ALLOC_RELAX_REQUIREMENTS_IMG (1 << 0) +#define CL_MEM_ALLOC_GPU_WRITE_COMBINE_IMG (1 << 1) +#define CL_MEM_ALLOC_GPU_CACHED_IMG (1 << 2) +#define CL_MEM_ALLOC_CPU_LOCAL_IMG (1 << 3) +#define CL_MEM_ALLOC_GPU_LOCAL_IMG (1 << 4) +#define CL_MEM_ALLOC_GPU_PRIVATE_IMG (1 << 5) -/* Flag values returned by clGetDeviceInfo with CL_DEVICE_SVM_CAPABILITIES_ARM as the param_name. */ -#define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER_ARM (1 << 0) -#define CL_DEVICE_SVM_FINE_GRAIN_BUFFER_ARM (1 << 1) -#define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM_ARM (1 << 2) -#define CL_DEVICE_SVM_ATOMICS_ARM (1 << 3) +/* cl_device_info */ +#define CL_DEVICE_MEMORY_CAPABILITIES_IMG 0x40D8 -/* Flag values used by clSVMAllocARM: */ -#define CL_MEM_SVM_FINE_GRAIN_BUFFER_ARM (1 << 10) -#define CL_MEM_SVM_ATOMICS_ARM (1 << 11) +/*************************************************************** +* cl_khr_subgroups +***************************************************************/ +#define cl_khr_subgroups 1 +#define CL_KHR_SUBGROUPS_EXTENSION_NAME \ + "cl_khr_subgroups" -typedef cl_bitfield cl_svm_mem_flags_arm; -typedef cl_uint cl_kernel_exec_info_arm; -typedef cl_bitfield cl_device_svm_capabilities_arm; -extern CL_API_ENTRY void * CL_API_CALL -clSVMAllocARM(cl_context context, - cl_svm_mem_flags_arm flags, - size_t size, - cl_uint alignment) CL_API_SUFFIX__VERSION_1_2; +#define CL_KHR_SUBGROUPS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY void CL_API_CALL -clSVMFreeARM(cl_context context, - void * svm_pointer) CL_API_SUFFIX__VERSION_1_2; +#if !defined(CL_VERSION_2_1) +/* defined in CL.h for OpenCL 2.1 and newer */ +typedef cl_uint cl_kernel_sub_group_info; -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMFreeARM(cl_command_queue command_queue, - cl_uint num_svm_pointers, - void * svm_pointers[], - void (CL_CALLBACK * pfn_free_func)(cl_command_queue queue, - cl_uint num_svm_pointers, - void * svm_pointers[], - void * user_data), - void * user_data, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_VERSION_2_1) */ -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMMemcpyARM(cl_command_queue command_queue, - cl_bool blocking_copy, - void * dst_ptr, - const void * src_ptr, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +/* cl_kernel_sub_group_info */ +#define CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR 0x2033 +#define CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR 0x2034 -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMMemFillARM(cl_command_queue command_queue, - void * svm_ptr, - const void * pattern, - size_t pattern_size, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMMapARM(cl_command_queue command_queue, - cl_bool blocking_map, - cl_map_flags flags, - void * svm_ptr, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +typedef cl_int CL_API_CALL +clGetKernelSubGroupInfoKHR_t( + cl_kernel in_kernel, + cl_device_id in_device, + cl_kernel_sub_group_info param_name, + size_t input_value_size, + const void* input_value, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMUnmapARM(cl_command_queue command_queue, - void * svm_ptr, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_2; +typedef clGetKernelSubGroupInfoKHR_t * +clGetKernelSubGroupInfoKHR_fn CL_API_SUFFIX__VERSION_2_0_DEPRECATED; -extern CL_API_ENTRY cl_int CL_API_CALL -clSetKernelArgSVMPointerARM(cl_kernel kernel, - cl_uint arg_index, - const void * arg_value) CL_API_SUFFIX__VERSION_1_2; +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL -clSetKernelExecInfoARM(cl_kernel kernel, - cl_kernel_exec_info_arm param_name, - size_t param_value_size, - const void * param_value) CL_API_SUFFIX__VERSION_1_2; - -/******************************** - * cl_arm_get_core_id extension * - ********************************/ +clGetKernelSubGroupInfoKHR( + cl_kernel in_kernel, + cl_device_id in_device, + cl_kernel_sub_group_info param_name, + size_t input_value_size, + const void* input_value, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_2_0_DEPRECATED; -#ifdef CL_VERSION_1_2 +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -#define cl_arm_get_core_id 1 +/*************************************************************** +* cl_khr_mipmap_image +***************************************************************/ +#define cl_khr_mipmap_image 1 +#define CL_KHR_MIPMAP_IMAGE_EXTENSION_NAME \ + "cl_khr_mipmap_image" -/* Device info property for bitfield of cores present */ -#define CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM 0x40BF -#endif /* CL_VERSION_1_2 */ +#define CL_KHR_MIPMAP_IMAGE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/********************************* -* cl_arm_job_slot_selection -*********************************/ +/* cl_sampler_properties */ +#define CL_SAMPLER_MIP_FILTER_MODE_KHR 0x1155 +#define CL_SAMPLER_LOD_MIN_KHR 0x1156 +#define CL_SAMPLER_LOD_MAX_KHR 0x1157 -#define cl_arm_job_slot_selection 1 +/*************************************************************** +* cl_khr_priority_hints +***************************************************************/ +#define cl_khr_priority_hints 1 +#define CL_KHR_PRIORITY_HINTS_EXTENSION_NAME \ + "cl_khr_priority_hints" -/* cl_device_info */ -#define CL_DEVICE_JOB_SLOTS_ARM 0x41E0 -/* cl_command_queue_properties */ -#define CL_QUEUE_JOB_SLOT_ARM 0x41E1 +#define CL_KHR_PRIORITY_HINTS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/********************************* -* cl_arm_scheduling_controls -*********************************/ +/* To be used by clGetEventInfo */ +typedef cl_uint cl_queue_priority_khr; -#define cl_arm_scheduling_controls 1 +/* cl_queue_properties */ +#define CL_QUEUE_PRIORITY_KHR 0x1096 -typedef cl_bitfield cl_device_scheduling_controls_capabilities_arm; +/* cl_queue_priority_khr */ +#define CL_QUEUE_PRIORITY_HIGH_KHR (1 << 0) +#define CL_QUEUE_PRIORITY_MED_KHR (1 << 1) +#define CL_QUEUE_PRIORITY_LOW_KHR (1 << 2) -/* cl_device_info */ -#define CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM 0x41E4 +/*************************************************************** +* cl_khr_throttle_hints +***************************************************************/ +#define cl_khr_throttle_hints 1 +#define CL_KHR_THROTTLE_HINTS_EXTENSION_NAME \ + "cl_khr_throttle_hints" -#define CL_DEVICE_SCHEDULING_KERNEL_BATCHING_ARM (1 << 0) -#define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_ARM (1 << 1) -#define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_MODIFIER_ARM (1 << 2) -#define CL_DEVICE_SCHEDULING_DEFERRED_FLUSH_ARM (1 << 3) -#define CL_DEVICE_SCHEDULING_REGISTER_ALLOCATION_ARM (1 << 4) -#define CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM 0x41EB +#define CL_KHR_THROTTLE_HINTS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_kernel_info */ -#define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM 0x41E5 -#define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM 0x41E6 +/* To be used by clGetEventInfo */ +typedef cl_uint cl_queue_throttle_khr; /* cl_queue_properties */ -#define CL_QUEUE_KERNEL_BATCHING_ARM 0x41E7 -#define CL_QUEUE_DEFERRED_FLUSH_ARM 0x41EC +#define CL_QUEUE_THROTTLE_KHR 0x1097 -/************************************** -* cl_arm_controlled_kernel_termination -***************************************/ +/* cl_queue_throttle_khr */ +#define CL_QUEUE_THROTTLE_HIGH_KHR (1 << 0) +#define CL_QUEUE_THROTTLE_MED_KHR (1 << 1) +#define CL_QUEUE_THROTTLE_LOW_KHR (1 << 2) + +/*************************************************************** +* cl_khr_subgroup_named_barrier +***************************************************************/ +#define cl_khr_subgroup_named_barrier 1 +#define CL_KHR_SUBGROUP_NAMED_BARRIER_EXTENSION_NAME \ + "cl_khr_subgroup_named_barrier" -#define cl_arm_controlled_kernel_termination 1 -/* Error code to indicate kernel terminated with failure */ -#define CL_COMMAND_TERMINATED_ITSELF_WITH_FAILURE_ARM -1108 +#define CL_KHR_SUBGROUP_NAMED_BARRIER_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /* cl_device_info */ -#define CL_DEVICE_CONTROLLED_TERMINATION_CAPABILITIES_ARM 0x41EE +#define CL_DEVICE_MAX_NAMED_BARRIER_COUNT_KHR 0x2035 -/* Bit fields for controlled termination feature query */ -typedef cl_bitfield cl_device_controlled_termination_capabilities_arm; +/*************************************************************** +* cl_khr_extended_versioning +***************************************************************/ +#define cl_khr_extended_versioning 1 +#define CL_KHR_EXTENDED_VERSIONING_EXTENSION_NAME \ + "cl_khr_extended_versioning" -#define CL_DEVICE_CONTROLLED_TERMINATION_SUCCESS_ARM (1 << 0) -#define CL_DEVICE_CONTROLLED_TERMINATION_FAILURE_ARM (1 << 1) -#define CL_DEVICE_CONTROLLED_TERMINATION_QUERY_ARM (1 << 2) -/* cl_event_info */ -#define CL_EVENT_COMMAND_TERMINATION_REASON_ARM 0x41ED +#define CL_KHR_EXTENDED_VERSIONING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* Values returned for event termination reason query */ -typedef cl_uint cl_command_termination_reason_arm; +#define CL_VERSION_MAJOR_BITS_KHR 10 +#define CL_VERSION_MINOR_BITS_KHR 10 +#define CL_VERSION_PATCH_BITS_KHR 12 -#define CL_COMMAND_TERMINATION_COMPLETION_ARM 0 -#define CL_COMMAND_TERMINATION_CONTROLLED_SUCCESS_ARM 1 -#define CL_COMMAND_TERMINATION_CONTROLLED_FAILURE_ARM 2 -#define CL_COMMAND_TERMINATION_ERROR_ARM 3 +#define CL_VERSION_MAJOR_MASK_KHR ((1 << CL_VERSION_MAJOR_BITS_KHR) - 1) +#define CL_VERSION_MINOR_MASK_KHR ((1 << CL_VERSION_MINOR_BITS_KHR) - 1) +#define CL_VERSION_PATCH_MASK_KHR ((1 << CL_VERSION_PATCH_BITS_KHR) - 1) -/************************************* -* cl_arm_protected_memory_allocation * -*************************************/ +#define CL_VERSION_MAJOR_KHR(version) ((version) >> (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) +#define CL_VERSION_MINOR_KHR(version) (((version) >> CL_VERSION_PATCH_BITS_KHR) & CL_VERSION_MINOR_MASK_KHR) +#define CL_VERSION_PATCH_KHR(version) ((version) & CL_VERSION_PATCH_MASK_KHR) -#define cl_arm_protected_memory_allocation 1 +#define CL_MAKE_VERSION_KHR(major, minor, patch) \ + ((((major) & CL_VERSION_MAJOR_MASK_KHR) << (CL_VERSION_MINOR_BITS_KHR + CL_VERSION_PATCH_BITS_KHR)) | \ + (((minor) & CL_VERSION_MINOR_MASK_KHR) << CL_VERSION_PATCH_BITS_KHR) | \ + ((patch) & CL_VERSION_PATCH_MASK_KHR)) -#define CL_MEM_PROTECTED_ALLOC_ARM (1ULL << 36) +#define CL_NAME_VERSION_MAX_NAME_SIZE_KHR 64 -/****************************************** -* cl_intel_exec_by_local_thread extension * -******************************************/ +typedef cl_uint cl_version_khr; +typedef struct _cl_name_version_khr { + cl_version_khr version; + char name[CL_NAME_VERSION_MAX_NAME_SIZE_KHR]; +} cl_name_version_khr; -#define cl_intel_exec_by_local_thread 1 +/* cl_platform_info */ +#define CL_PLATFORM_NUMERIC_VERSION_KHR 0x0906 +#define CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR 0x0907 -#define CL_QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL (((cl_bitfield)1) << 31) +/* cl_device_info */ +#define CL_DEVICE_NUMERIC_VERSION_KHR 0x105E +#define CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR 0x105F +#define CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR 0x1060 +#define CL_DEVICE_ILS_WITH_VERSION_KHR 0x1061 +#define CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR 0x1062 /*************************************************************** -* cl_intel_device_attribute_query +* cl_khr_device_uuid ***************************************************************/ +#define cl_khr_device_uuid 1 +#define CL_KHR_DEVICE_UUID_EXTENSION_NAME \ + "cl_khr_device_uuid" -#define cl_intel_device_attribute_query 1 -typedef cl_bitfield cl_device_feature_capabilities_intel; +#define CL_KHR_DEVICE_UUID_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_device_feature_capabilities_intel */ -#define CL_DEVICE_FEATURE_FLAG_DP4A_INTEL (1 << 0) -#define CL_DEVICE_FEATURE_FLAG_DPAS_INTEL (1 << 1) +/* Size Constants */ +#define CL_UUID_SIZE_KHR 16 +#define CL_LUID_SIZE_KHR 8 /* cl_device_info */ -#define CL_DEVICE_IP_VERSION_INTEL 0x4250 -#define CL_DEVICE_ID_INTEL 0x4251 -#define CL_DEVICE_NUM_SLICES_INTEL 0x4252 -#define CL_DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL 0x4253 -#define CL_DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL 0x4254 -#define CL_DEVICE_NUM_THREADS_PER_EU_INTEL 0x4255 -#define CL_DEVICE_FEATURE_CAPABILITIES_INTEL 0x4256 +#define CL_DEVICE_UUID_KHR 0x106A +#define CL_DRIVER_UUID_KHR 0x106B +#define CL_DEVICE_LUID_VALID_KHR 0x106C +#define CL_DEVICE_LUID_KHR 0x106D +#define CL_DEVICE_NODE_MASK_KHR 0x106E -/*********************************************** -* cl_intel_device_partition_by_names extension * -************************************************/ +/*************************************************************** +* cl_khr_pci_bus_info +***************************************************************/ +#define cl_khr_pci_bus_info 1 +#define CL_KHR_PCI_BUS_INFO_EXTENSION_NAME \ + "cl_khr_pci_bus_info" -#define cl_intel_device_partition_by_names 1 -#define CL_DEVICE_PARTITION_BY_NAMES_INTEL 0x4052 -#define CL_PARTITION_BY_NAMES_LIST_END_INTEL -1 +#define CL_KHR_PCI_BUS_INFO_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/************************************************ -* cl_intel_accelerator extension * -* cl_intel_motion_estimation extension * -* cl_intel_advanced_motion_estimation extension * -*************************************************/ +typedef struct _cl_device_pci_bus_info_khr { + cl_uint pci_domain; + cl_uint pci_bus; + cl_uint pci_device; + cl_uint pci_function; +} cl_device_pci_bus_info_khr; -#define cl_intel_accelerator 1 -#define cl_intel_motion_estimation 1 -#define cl_intel_advanced_motion_estimation 1 +/* cl_device_info */ +#define CL_DEVICE_PCI_BUS_INFO_KHR 0x410F -typedef struct _cl_accelerator_intel* cl_accelerator_intel; -typedef cl_uint cl_accelerator_type_intel; -typedef cl_uint cl_accelerator_info_intel; +/*************************************************************** +* cl_khr_suggested_local_work_size +***************************************************************/ +#define cl_khr_suggested_local_work_size 1 +#define CL_KHR_SUGGESTED_LOCAL_WORK_SIZE_EXTENSION_NAME \ + "cl_khr_suggested_local_work_size" -typedef struct _cl_motion_estimation_desc_intel { - cl_uint mb_block_type; - cl_uint subpixel_mode; - cl_uint sad_adjust_mode; - cl_uint search_path_type; -} cl_motion_estimation_desc_intel; -/* error codes */ -#define CL_INVALID_ACCELERATOR_INTEL -1094 -#define CL_INVALID_ACCELERATOR_TYPE_INTEL -1095 -#define CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL -1096 -#define CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL -1097 +#define CL_KHR_SUGGESTED_LOCAL_WORK_SIZE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_accelerator_type_intel */ -#define CL_ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL 0x0 -/* cl_accelerator_info_intel */ -#define CL_ACCELERATOR_DESCRIPTOR_INTEL 0x4090 -#define CL_ACCELERATOR_REFERENCE_COUNT_INTEL 0x4091 -#define CL_ACCELERATOR_CONTEXT_INTEL 0x4092 -#define CL_ACCELERATOR_TYPE_INTEL 0x4093 - -/* cl_motion_detect_desc_intel flags */ -#define CL_ME_MB_TYPE_16x16_INTEL 0x0 -#define CL_ME_MB_TYPE_8x8_INTEL 0x1 -#define CL_ME_MB_TYPE_4x4_INTEL 0x2 - -#define CL_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 -#define CL_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 -#define CL_ME_SUBPIXEL_MODE_QPEL_INTEL 0x2 - -#define CL_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 -#define CL_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x1 - -#define CL_ME_SEARCH_PATH_RADIUS_2_2_INTEL 0x0 -#define CL_ME_SEARCH_PATH_RADIUS_4_4_INTEL 0x1 -#define CL_ME_SEARCH_PATH_RADIUS_16_12_INTEL 0x5 - -#define CL_ME_SKIP_BLOCK_TYPE_16x16_INTEL 0x0 -#define CL_ME_CHROMA_INTRA_PREDICT_ENABLED_INTEL 0x1 -#define CL_ME_LUMA_INTRA_PREDICT_ENABLED_INTEL 0x2 -#define CL_ME_SKIP_BLOCK_TYPE_8x8_INTEL 0x4 - -#define CL_ME_FORWARD_INPUT_MODE_INTEL 0x1 -#define CL_ME_BACKWARD_INPUT_MODE_INTEL 0x2 -#define CL_ME_BIDIRECTION_INPUT_MODE_INTEL 0x3 - -#define CL_ME_BIDIR_WEIGHT_QUARTER_INTEL 16 -#define CL_ME_BIDIR_WEIGHT_THIRD_INTEL 21 -#define CL_ME_BIDIR_WEIGHT_HALF_INTEL 32 -#define CL_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 43 -#define CL_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 48 - -#define CL_ME_COST_PENALTY_NONE_INTEL 0x0 -#define CL_ME_COST_PENALTY_LOW_INTEL 0x1 -#define CL_ME_COST_PENALTY_NORMAL_INTEL 0x2 -#define CL_ME_COST_PENALTY_HIGH_INTEL 0x3 - -#define CL_ME_COST_PRECISION_QPEL_INTEL 0x0 -#define CL_ME_COST_PRECISION_HPEL_INTEL 0x1 -#define CL_ME_COST_PRECISION_PEL_INTEL 0x2 -#define CL_ME_COST_PRECISION_DPEL_INTEL 0x3 - -#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 -#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CL_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 -#define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 - -#define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 -#define CL_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 -#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 -#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 -#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 -#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 - -#define CL_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 -#define CL_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CL_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 -#define CL_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 +typedef cl_int CL_API_CALL +clGetKernelSuggestedLocalWorkSizeKHR_t( + cl_command_queue command_queue, + cl_kernel kernel, + cl_uint work_dim, + const size_t* global_work_offset, + const size_t* global_work_size, + size_t* suggested_local_work_size); -/* cl_device_info */ -#define CL_DEVICE_ME_VERSION_INTEL 0x407E +typedef clGetKernelSuggestedLocalWorkSizeKHR_t * +clGetKernelSuggestedLocalWorkSizeKHR_fn CL_API_SUFFIX__VERSION_3_0; -#define CL_ME_VERSION_LEGACY_INTEL 0x0 -#define CL_ME_VERSION_ADVANCED_VER_1_INTEL 0x1 -#define CL_ME_VERSION_ADVANCED_VER_2_INTEL 0x2 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -extern CL_API_ENTRY cl_accelerator_intel CL_API_CALL -clCreateAcceleratorINTEL( - cl_context context, - cl_accelerator_type_intel accelerator_type, - size_t descriptor_size, - const void* descriptor, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; +extern CL_API_ENTRY cl_int CL_API_CALL +clGetKernelSuggestedLocalWorkSizeKHR( + cl_command_queue command_queue, + cl_kernel kernel, + cl_uint work_dim, + const size_t* global_work_offset, + const size_t* global_work_size, + size_t* suggested_local_work_size) CL_API_SUFFIX__VERSION_3_0; -typedef cl_accelerator_intel (CL_API_CALL *clCreateAcceleratorINTEL_fn)( - cl_context context, - cl_accelerator_type_intel accelerator_type, - size_t descriptor_size, - const void* descriptor, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetAcceleratorInfoINTEL( - cl_accelerator_intel accelerator, - cl_accelerator_info_intel param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; +/*************************************************************** +* cl_khr_integer_dot_product +***************************************************************/ +#define cl_khr_integer_dot_product 1 +#define CL_KHR_INTEGER_DOT_PRODUCT_EXTENSION_NAME \ + "cl_khr_integer_dot_product" -typedef cl_int (CL_API_CALL *clGetAcceleratorInfoINTEL_fn)( - cl_accelerator_intel accelerator, - cl_accelerator_info_intel param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; -extern CL_API_ENTRY cl_int CL_API_CALL -clRetainAcceleratorINTEL( - cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; +#define CL_KHR_INTEGER_DOT_PRODUCT_EXTENSION_VERSION CL_MAKE_VERSION(2, 0, 0) -typedef cl_int (CL_API_CALL *clRetainAcceleratorINTEL_fn)( - cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; +typedef cl_bitfield cl_device_integer_dot_product_capabilities_khr; +typedef struct _cl_device_integer_dot_product_acceleration_properties_khr { + cl_bool signed_accelerated; + cl_bool unsigned_accelerated; + cl_bool mixed_signedness_accelerated; + cl_bool accumulating_saturating_signed_accelerated; + cl_bool accumulating_saturating_unsigned_accelerated; + cl_bool accumulating_saturating_mixed_signedness_accelerated; +} cl_device_integer_dot_product_acceleration_properties_khr; -extern CL_API_ENTRY cl_int CL_API_CALL -clReleaseAcceleratorINTEL( - cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; +/* cl_device_integer_dot_product_capabilities_khr */ +#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_PACKED_KHR (1 << 0) +#define CL_DEVICE_INTEGER_DOT_PRODUCT_INPUT_4x8BIT_KHR (1 << 1) -typedef cl_int (CL_API_CALL *clReleaseAcceleratorINTEL_fn)( - cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; +/* cl_device_info */ +#define CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR 0x1073 +#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR 0x1074 +#define CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_4x8BIT_PACKED_KHR 0x1075 -/****************************************** -* cl_intel_simultaneous_sharing extension * -*******************************************/ +/*************************************************************** +* cl_khr_external_memory +***************************************************************/ +#define cl_khr_external_memory 1 +#define CL_KHR_EXTERNAL_MEMORY_EXTENSION_NAME \ + "cl_khr_external_memory" -#define cl_intel_simultaneous_sharing 1 -#define CL_DEVICE_SIMULTANEOUS_INTEROPS_INTEL 0x4104 -#define CL_DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL 0x4105 +#define CL_KHR_EXTERNAL_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 1) -/*********************************** -* cl_intel_egl_image_yuv extension * -************************************/ +typedef cl_uint cl_external_memory_handle_type_khr; -#define cl_intel_egl_image_yuv 1 +/* cl_platform_info */ +#define CL_PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x2044 -#define CL_EGL_YUV_PLANE_INTEL 0x4107 +/* cl_device_info */ +#define CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR 0x204F +#define CL_DEVICE_EXTERNAL_MEMORY_IMPORT_ASSUME_LINEAR_IMAGES_HANDLE_TYPES_KHR 0x2052 -/******************************** -* cl_intel_packed_yuv extension * -*********************************/ +/* cl_mem_properties */ +#define CL_MEM_DEVICE_HANDLE_LIST_KHR 0x2051 +#define CL_MEM_DEVICE_HANDLE_LIST_END_KHR 0 -#define cl_intel_packed_yuv 1 +/* cl_command_type */ +#define CL_COMMAND_ACQUIRE_EXTERNAL_MEM_OBJECTS_KHR 0x2047 +#define CL_COMMAND_RELEASE_EXTERNAL_MEM_OBJECTS_KHR 0x2048 -#define CL_YUYV_INTEL 0x4076 -#define CL_UYVY_INTEL 0x4077 -#define CL_YVYU_INTEL 0x4078 -#define CL_VYUY_INTEL 0x4079 -/******************************************** -* cl_intel_required_subgroup_size extension * -*********************************************/ +typedef cl_int CL_API_CALL +clEnqueueAcquireExternalMemObjectsKHR_t( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -#define cl_intel_required_subgroup_size 1 +typedef clEnqueueAcquireExternalMemObjectsKHR_t * +clEnqueueAcquireExternalMemObjectsKHR_fn CL_API_SUFFIX__VERSION_3_0; -#define CL_DEVICE_SUB_GROUP_SIZES_INTEL 0x4108 -#define CL_KERNEL_SPILL_MEM_SIZE_INTEL 0x4109 -#define CL_KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL 0x410A +typedef cl_int CL_API_CALL +clEnqueueReleaseExternalMemObjectsKHR_t( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); -/**************************************** -* cl_intel_driver_diagnostics extension * -*****************************************/ +typedef clEnqueueReleaseExternalMemObjectsKHR_t * +clEnqueueReleaseExternalMemObjectsKHR_fn CL_API_SUFFIX__VERSION_3_0; -#define cl_intel_driver_diagnostics 1 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -typedef cl_uint cl_diagnostics_verbose_level; +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueAcquireExternalMemObjectsKHR( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_3_0; -#define CL_CONTEXT_SHOW_DIAGNOSTICS_INTEL 0x4106 +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReleaseExternalMemObjectsKHR( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_3_0; -#define CL_CONTEXT_DIAGNOSTICS_LEVEL_ALL_INTEL ( 0xff ) -#define CL_CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL ( 1 ) -#define CL_CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL ( 1 << 1 ) -#define CL_CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL ( 1 << 2 ) +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -/******************************** -* cl_intel_planar_yuv extension * -*********************************/ +/*************************************************************** +* cl_khr_external_memory_dma_buf +***************************************************************/ +#define cl_khr_external_memory_dma_buf 1 +#define CL_KHR_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME \ + "cl_khr_external_memory_dma_buf" -#define CL_NV12_INTEL 0x410E -#define CL_MEM_NO_ACCESS_INTEL ( 1 << 24 ) -#define CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL ( 1 << 25 ) +#define CL_KHR_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -#define CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL 0x417E -#define CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL 0x417F +/* cl_external_memory_handle_type_khr */ +#define CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR 0x2067 -/******************************************************* -* cl_intel_device_side_avc_motion_estimation extension * -********************************************************/ +/*************************************************************** +* cl_khr_external_memory_opaque_fd +***************************************************************/ +#define cl_khr_external_memory_opaque_fd 1 +#define CL_KHR_EXTERNAL_MEMORY_OPAQUE_FD_EXTENSION_NAME \ + "cl_khr_external_memory_opaque_fd" -#define CL_DEVICE_AVC_ME_VERSION_INTEL 0x410B -#define CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL 0x410C -#define CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL 0x410D -#define CL_AVC_ME_VERSION_0_INTEL 0x0 /* No support. */ -#define CL_AVC_ME_VERSION_1_INTEL 0x1 /* First supported version. */ +#define CL_KHR_EXTERNAL_MEMORY_OPAQUE_FD_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -#define CL_AVC_ME_MAJOR_16x16_INTEL 0x0 -#define CL_AVC_ME_MAJOR_16x8_INTEL 0x1 -#define CL_AVC_ME_MAJOR_8x16_INTEL 0x2 -#define CL_AVC_ME_MAJOR_8x8_INTEL 0x3 +/* cl_external_memory_handle_type_khr */ +#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR 0x2060 -#define CL_AVC_ME_MINOR_8x8_INTEL 0x0 -#define CL_AVC_ME_MINOR_8x4_INTEL 0x1 -#define CL_AVC_ME_MINOR_4x8_INTEL 0x2 -#define CL_AVC_ME_MINOR_4x4_INTEL 0x3 +/*************************************************************** +* cl_khr_external_memory_win32 +***************************************************************/ +#define cl_khr_external_memory_win32 1 +#define CL_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME \ + "cl_khr_external_memory_win32" -#define CL_AVC_ME_MAJOR_FORWARD_INTEL 0x0 -#define CL_AVC_ME_MAJOR_BACKWARD_INTEL 0x1 -#define CL_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2 -#define CL_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0 -#define CL_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E -#define CL_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D -#define CL_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B -#define CL_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77 -#define CL_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F -#define CL_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F -#define CL_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F +#define CL_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_VERSION CL_MAKE_VERSION(1, 1, 0) -#define CL_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0 -#define CL_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1 -#define CL_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2 -#define CL_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3 -#define CL_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4 -#define CL_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5 -#define CL_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6 -#define CL_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7 -#define CL_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8 -#define CL_AVC_ME_SEARCH_WINDOW_16x12_RADIUS_INTEL 0x9 -#define CL_AVC_ME_SEARCH_WINDOW_4x4_RADIUS_INTEL 0x2 -#define CL_AVC_ME_SEARCH_WINDOW_2x2_RADIUS_INTEL 0xa +/* cl_external_memory_handle_type_khr */ +#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR 0x2061 +#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2062 +#define CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_NAME_KHR 0x2069 -#define CL_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 -#define CL_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2 +/*************************************************************** +* cl_khr_external_semaphore +***************************************************************/ +#define cl_khr_external_semaphore 1 +#define CL_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME \ + "cl_khr_external_semaphore" -#define CL_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 -#define CL_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 -#define CL_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3 -#define CL_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0 -#define CL_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1 -#define CL_AVC_ME_COST_PRECISION_PEL_INTEL 0x2 -#define CL_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3 +#define CL_KHR_EXTERNAL_SEMAPHORE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 1) -#define CL_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10 -#define CL_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15 -#define CL_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20 -#define CL_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B -#define CL_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30 +typedef struct _cl_semaphore_khr * cl_semaphore_khr; +typedef cl_uint cl_external_semaphore_handle_type_khr; -#define CL_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0 -#define CL_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2 -#define CL_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4 -#define CL_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8 +/* cl_platform_info */ +#define CL_PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x2037 +#define CL_PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x2038 -#define CL_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0 -#define CL_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000 +/* cl_device_info */ +#define CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR 0x204D +#define CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x204E -#define CL_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL ( 0x1 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL ( 0x2 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL ( 0x3 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL ( 0x55 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL ( 0xAA << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL ( 0xFF << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL ( 0x1 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL ( 0x2 << 24 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL ( 0x1 << 26 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL ( 0x2 << 26 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL ( 0x1 << 28 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL ( 0x2 << 28 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL ( 0x1 << 30 ) -#define CL_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL ( 0x2 << 30 ) +/* cl_semaphore_properties_khr */ +#define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR 0x203F +#define CL_SEMAPHORE_EXPORT_HANDLE_TYPES_LIST_END_KHR 0 -#define CL_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00 -#define CL_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80 +/* cl_semaphore_info_khr */ +#define CL_SEMAPHORE_EXPORTABLE_KHR 0x2054 -#define CL_AVC_ME_INTRA_16x16_INTEL 0x0 -#define CL_AVC_ME_INTRA_8x8_INTEL 0x1 -#define CL_AVC_ME_INTRA_4x4_INTEL 0x2 -#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6 -#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5 -#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3 +typedef cl_int CL_API_CALL +clGetSemaphoreHandleForTypeKHR_t( + cl_semaphore_khr sema_object, + cl_device_id device, + cl_external_semaphore_handle_type_khr handle_type, + size_t handle_size, + void* handle_ptr, + size_t* handle_size_ret); -#define CL_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60 -#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10 -#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8 -#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4 +typedef clGetSemaphoreHandleForTypeKHR_t * +clGetSemaphoreHandleForTypeKHR_fn CL_API_SUFFIX__VERSION_1_2; -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 -#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 -#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 -#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 -#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 -#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -#define CL_AVC_ME_FRAME_FORWARD_INTEL 0x1 -#define CL_AVC_ME_FRAME_BACKWARD_INTEL 0x2 -#define CL_AVC_ME_FRAME_DUAL_INTEL 0x3 +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSemaphoreHandleForTypeKHR( + cl_semaphore_khr sema_object, + cl_device_id device, + cl_external_semaphore_handle_type_khr handle_type, + size_t handle_size, + void* handle_ptr, + size_t* handle_size_ret) CL_API_SUFFIX__VERSION_1_2; -#define CL_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0 -#define CL_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1 -#define CL_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2 +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ -#define CL_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0 -#define CL_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1 +/*************************************************************** +* cl_khr_external_semaphore_opaque_fd +***************************************************************/ +#define cl_khr_external_semaphore_opaque_fd 1 +#define CL_KHR_EXTERNAL_SEMAPHORE_OPAQUE_FD_EXTENSION_NAME \ + "cl_khr_external_semaphore_opaque_fd" -/******************************************* -* cl_intel_unified_shared_memory extension * -********************************************/ -#define cl_intel_unified_shared_memory 1 -typedef cl_bitfield cl_device_unified_shared_memory_capabilities_intel; -typedef cl_properties cl_mem_properties_intel; -typedef cl_bitfield cl_mem_alloc_flags_intel; -typedef cl_uint cl_mem_info_intel; -typedef cl_uint cl_unified_shared_memory_type_intel; -typedef cl_uint cl_mem_advice_intel; +#define CL_KHR_EXTERNAL_SEMAPHORE_OPAQUE_FD_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_device_info */ -#define CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL 0x4190 -#define CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL 0x4191 -#define CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4192 -#define CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4193 -#define CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL 0x4194 +/* cl_external_semaphore_handle_type_khr */ +#define CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR 0x2055 -/* cl_device_unified_shared_memory_capabilities_intel - bitfield */ -#define CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL (1 << 0) -#define CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL (1 << 1) -#define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL (1 << 2) -#define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL (1 << 3) +/*************************************************************** +* cl_khr_external_semaphore_sync_fd +***************************************************************/ +#define cl_khr_external_semaphore_sync_fd 1 +#define CL_KHR_EXTERNAL_SEMAPHORE_SYNC_FD_EXTENSION_NAME \ + "cl_khr_external_semaphore_sync_fd" -/* cl_mem_properties_intel */ -#define CL_MEM_ALLOC_FLAGS_INTEL 0x4195 -/* cl_mem_alloc_flags_intel - bitfield */ -#define CL_MEM_ALLOC_WRITE_COMBINED_INTEL (1 << 0) -#define CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL (1 << 1) -#define CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL (1 << 2) +#define CL_KHR_EXTERNAL_SEMAPHORE_SYNC_FD_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_mem_alloc_info_intel */ -#define CL_MEM_ALLOC_TYPE_INTEL 0x419A -#define CL_MEM_ALLOC_BASE_PTR_INTEL 0x419B -#define CL_MEM_ALLOC_SIZE_INTEL 0x419C -#define CL_MEM_ALLOC_DEVICE_INTEL 0x419D +typedef cl_properties cl_semaphore_reimport_properties_khr; -/* cl_unified_shared_memory_type_intel */ -#define CL_MEM_TYPE_UNKNOWN_INTEL 0x4196 -#define CL_MEM_TYPE_HOST_INTEL 0x4197 -#define CL_MEM_TYPE_DEVICE_INTEL 0x4198 -#define CL_MEM_TYPE_SHARED_INTEL 0x4199 +/* cl_external_semaphore_handle_type_khr */ +#define CL_SEMAPHORE_HANDLE_SYNC_FD_KHR 0x2058 -/* cl_kernel_exec_info */ -#define CL_KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL 0x4200 -#define CL_KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL 0x4201 -#define CL_KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL 0x4202 -#define CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL 0x4203 + +typedef cl_int CL_API_CALL +clReImportSemaphoreSyncFdKHR_t( + cl_semaphore_khr sema_object, + cl_semaphore_reimport_properties_khr* reimport_props, + int fd); + +typedef clReImportSemaphoreSyncFdKHR_t * +clReImportSemaphoreSyncFdKHR_fn CL_API_SUFFIX__VERSION_3_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clReImportSemaphoreSyncFdKHR( + cl_semaphore_khr sema_object, + cl_semaphore_reimport_properties_khr* reimport_props, + int fd) CL_API_SUFFIX__VERSION_3_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_khr_external_semaphore_win32 +***************************************************************/ +#define cl_khr_external_semaphore_win32 1 +#define CL_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME \ + "cl_khr_external_semaphore_win32" + + +#define CL_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_VERSION CL_MAKE_VERSION(0, 9, 1) + +/* cl_external_semaphore_handle_type_khr */ +#define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR 0x2056 +#define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR 0x2057 +#define CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_NAME_KHR 0x2068 + +/*************************************************************** +* cl_khr_semaphore +***************************************************************/ +#define cl_khr_semaphore 1 +#define CL_KHR_SEMAPHORE_EXTENSION_NAME \ + "cl_khr_semaphore" + + +#define CL_KHR_SEMAPHORE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* type cl_semaphore_khr */ +typedef cl_properties cl_semaphore_properties_khr; +typedef cl_uint cl_semaphore_info_khr; +typedef cl_uint cl_semaphore_type_khr; +typedef cl_ulong cl_semaphore_payload_khr; + +/* cl_semaphore_type */ +#define CL_SEMAPHORE_TYPE_BINARY_KHR 1 + +/* cl_platform_info */ +#define CL_PLATFORM_SEMAPHORE_TYPES_KHR 0x2036 + +/* cl_device_info */ +#define CL_DEVICE_SEMAPHORE_TYPES_KHR 0x204C + +/* cl_semaphore_info_khr */ +#define CL_SEMAPHORE_CONTEXT_KHR 0x2039 +#define CL_SEMAPHORE_REFERENCE_COUNT_KHR 0x203A +#define CL_SEMAPHORE_PROPERTIES_KHR 0x203B +#define CL_SEMAPHORE_PAYLOAD_KHR 0x203C + +/* cl_semaphore_info_khr or cl_semaphore_properties_khr */ +#define CL_SEMAPHORE_TYPE_KHR 0x203D +#define CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR 0x2053 +#define CL_SEMAPHORE_DEVICE_HANDLE_LIST_END_KHR 0 /* cl_command_type */ -#define CL_COMMAND_MEMFILL_INTEL 0x4204 -#define CL_COMMAND_MEMCPY_INTEL 0x4205 -#define CL_COMMAND_MIGRATEMEM_INTEL 0x4206 -#define CL_COMMAND_MEMADVISE_INTEL 0x4207 +#define CL_COMMAND_SEMAPHORE_WAIT_KHR 0x2042 +#define CL_COMMAND_SEMAPHORE_SIGNAL_KHR 0x2043 +/* Error codes */ +#define CL_INVALID_SEMAPHORE_KHR -1142 -typedef void* (CL_API_CALL * -clHostMemAllocINTEL_fn)( - cl_context context, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; -typedef void* (CL_API_CALL * -clDeviceMemAllocINTEL_fn)( +typedef cl_semaphore_khr CL_API_CALL +clCreateSemaphoreWithPropertiesKHR_t( cl_context context, - cl_device_id device, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; + const cl_semaphore_properties_khr* sema_props, + cl_int* errcode_ret); -typedef void* (CL_API_CALL * -clSharedMemAllocINTEL_fn)( - cl_context context, - cl_device_id device, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; +typedef clCreateSemaphoreWithPropertiesKHR_t * +clCreateSemaphoreWithPropertiesKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueWaitSemaphoresKHR_t( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueWaitSemaphoresKHR_t * +clEnqueueWaitSemaphoresKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSignalSemaphoresKHR_t( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSignalSemaphoresKHR_t * +clEnqueueSignalSemaphoresKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clGetSemaphoreInfoKHR_t( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetSemaphoreInfoKHR_t * +clGetSemaphoreInfoKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clReleaseSemaphoreKHR_t( + cl_semaphore_khr sema_object); + +typedef clReleaseSemaphoreKHR_t * +clReleaseSemaphoreKHR_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clRetainSemaphoreKHR_t( + cl_semaphore_khr sema_object); -typedef cl_int (CL_API_CALL * -clMemFreeINTEL_fn)( +typedef clRetainSemaphoreKHR_t * +clRetainSemaphoreKHR_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_semaphore_khr CL_API_CALL +clCreateSemaphoreWithPropertiesKHR( cl_context context, - void* ptr) ; + const cl_semaphore_properties_khr* sema_props, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWaitSemaphoresKHR( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSignalSemaphoresKHR( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSemaphoreInfoKHR( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseSemaphoreKHR( + cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainSemaphoreKHR( + cl_semaphore_khr sema_object) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_arm_import_memory +***************************************************************/ +#define cl_arm_import_memory 1 +#define CL_ARM_IMPORT_MEMORY_EXTENSION_NAME \ + "cl_arm_import_memory" + + +#define CL_ARM_IMPORT_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef intptr_t cl_import_properties_arm; + +/* cl_import_properties_arm */ +#define CL_IMPORT_TYPE_ARM 0x40B2 +#define CL_IMPORT_TYPE_HOST_ARM 0x40B3 +#define CL_IMPORT_TYPE_DMA_BUF_ARM 0x40B4 +#define CL_IMPORT_TYPE_PROTECTED_ARM 0x40B5 +#define CL_IMPORT_TYPE_ANDROID_HARDWARE_BUFFER_ARM 0x41E2 +#define CL_IMPORT_DMA_BUF_DATA_CONSISTENCY_WITH_HOST_ARM 0x41E3 +#define CL_IMPORT_MEMORY_WHOLE_ALLOCATION_ARM SIZE_MAX +#define CL_IMPORT_ANDROID_HARDWARE_BUFFER_PLANE_INDEX_ARM 0x41EF +#define CL_IMPORT_ANDROID_HARDWARE_BUFFER_LAYER_INDEX_ARM 0x41F0 + + +typedef cl_mem CL_API_CALL +clImportMemoryARM_t( + cl_context context, + cl_mem_flags flags, + const cl_import_properties_arm* properties, + void* memory, + size_t size, + cl_int* errcode_ret); + +typedef clImportMemoryARM_t * +clImportMemoryARM_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_mem CL_API_CALL +clImportMemoryARM( + cl_context context, + cl_mem_flags flags, + const cl_import_properties_arm* properties, + void* memory, + size_t size, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_arm_shared_virtual_memory +***************************************************************/ +#define cl_arm_shared_virtual_memory 1 +#define CL_ARM_SHARED_VIRTUAL_MEMORY_EXTENSION_NAME \ + "cl_arm_shared_virtual_memory" + + +#define CL_ARM_SHARED_VIRTUAL_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef cl_bitfield cl_svm_mem_flags_arm; +typedef cl_uint cl_kernel_exec_info_arm; +typedef cl_bitfield cl_device_svm_capabilities_arm; + +/* cl_device_info */ +#define CL_DEVICE_SVM_CAPABILITIES_ARM 0x40B6 + +/* cl_mem_info */ +#define CL_MEM_USES_SVM_POINTER_ARM 0x40B7 + +/* cl_kernel_exec_info_arm */ +#define CL_KERNEL_EXEC_INFO_SVM_PTRS_ARM 0x40B8 +#define CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM_ARM 0x40B9 + +/* cl_command_type */ +#define CL_COMMAND_SVM_FREE_ARM 0x40BA +#define CL_COMMAND_SVM_MEMCPY_ARM 0x40BB +#define CL_COMMAND_SVM_MEMFILL_ARM 0x40BC +#define CL_COMMAND_SVM_MAP_ARM 0x40BD +#define CL_COMMAND_SVM_UNMAP_ARM 0x40BE + +/* cl_device_svm_capabilities_arm */ +#define CL_DEVICE_SVM_COARSE_GRAIN_BUFFER_ARM (1 << 0) +#define CL_DEVICE_SVM_FINE_GRAIN_BUFFER_ARM (1 << 1) +#define CL_DEVICE_SVM_FINE_GRAIN_SYSTEM_ARM (1 << 2) +#define CL_DEVICE_SVM_ATOMICS_ARM (1 << 3) + +/* cl_svm_mem_flags_arm */ +#define CL_MEM_SVM_FINE_GRAIN_BUFFER_ARM (1 << 10) +#define CL_MEM_SVM_ATOMICS_ARM (1 << 11) + + +typedef void* CL_API_CALL +clSVMAllocARM_t( + cl_context context, + cl_svm_mem_flags_arm flags, + size_t size, + cl_uint alignment); + +typedef clSVMAllocARM_t * +clSVMAllocARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef void CL_API_CALL +clSVMFreeARM_t( + cl_context context, + void* svm_pointer); + +typedef clSVMFreeARM_t * +clSVMFreeARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSVMFreeARM_t( + cl_command_queue command_queue, + cl_uint num_svm_pointers, + void* svm_pointers[], + void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void * svm_pointers[], void *user_data), + void* user_data, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMFreeARM_t * +clEnqueueSVMFreeARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSVMMemcpyARM_t( + cl_command_queue command_queue, + cl_bool blocking_copy, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMemcpyARM_t * +clEnqueueSVMMemcpyARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSVMMemFillARM_t( + cl_command_queue command_queue, + void* svm_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMemFillARM_t * +clEnqueueSVMMemFillARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSVMMapARM_t( + cl_command_queue command_queue, + cl_bool blocking_map, + cl_map_flags flags, + void* svm_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMapARM_t * +clEnqueueSVMMapARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueSVMUnmapARM_t( + cl_command_queue command_queue, + void* svm_ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMUnmapARM_t * +clEnqueueSVMUnmapARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clSetKernelArgSVMPointerARM_t( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value); + +typedef clSetKernelArgSVMPointerARM_t * +clSetKernelArgSVMPointerARM_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clSetKernelExecInfoARM_t( + cl_kernel kernel, + cl_kernel_exec_info_arm param_name, + size_t param_value_size, + const void* param_value); + +typedef clSetKernelExecInfoARM_t * +clSetKernelExecInfoARM_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY void* CL_API_CALL +clSVMAllocARM( + cl_context context, + cl_svm_mem_flags_arm flags, + size_t size, + cl_uint alignment) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY void CL_API_CALL +clSVMFreeARM( + cl_context context, + void* svm_pointer) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSVMFreeARM( + cl_command_queue command_queue, + cl_uint num_svm_pointers, + void* svm_pointers[], + void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void * svm_pointers[], void *user_data), + void* user_data, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSVMMemcpyARM( + cl_command_queue command_queue, + cl_bool blocking_copy, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSVMMemFillARM( + cl_command_queue command_queue, + void* svm_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSVMMapARM( + cl_command_queue command_queue, + cl_bool blocking_map, + cl_map_flags flags, + void* svm_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueSVMUnmapARM( + cl_command_queue command_queue, + void* svm_ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetKernelArgSVMPointerARM( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetKernelExecInfoARM( + cl_kernel kernel, + cl_kernel_exec_info_arm param_name, + size_t param_value_size, + const void* param_value) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_arm_get_core_id +***************************************************************/ +#if defined(CL_VERSION_1_2) + +#define cl_arm_get_core_id 1 +#define CL_ARM_GET_CORE_ID_EXTENSION_NAME \ + "cl_arm_get_core_id" + + +#define CL_ARM_GET_CORE_ID_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_COMPUTE_UNITS_BITFIELD_ARM 0x40BF + +#endif /* defined(CL_VERSION_1_2) */ + +/*************************************************************** +* cl_arm_job_slot_selection +***************************************************************/ +#define cl_arm_job_slot_selection 1 +#define CL_ARM_JOB_SLOT_SELECTION_EXTENSION_NAME \ + "cl_arm_job_slot_selection" + + +#define CL_ARM_JOB_SLOT_SELECTION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_JOB_SLOTS_ARM 0x41E0 + +/* cl_queue_properties */ +#define CL_QUEUE_JOB_SLOT_ARM 0x41E1 + +/*************************************************************** +* cl_arm_scheduling_controls +***************************************************************/ +#define cl_arm_scheduling_controls 1 +#define CL_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME \ + "cl_arm_scheduling_controls" + + +#define CL_ARM_SCHEDULING_CONTROLS_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* Types */ +typedef cl_bitfield cl_device_scheduling_controls_capabilities_arm; + +/* cl_device_scheduling_controls_capabilities_arm */ +#define CL_DEVICE_SCHEDULING_KERNEL_BATCHING_ARM (1 << 0) +#define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_ARM (1 << 1) +#define CL_DEVICE_SCHEDULING_WORKGROUP_BATCH_SIZE_MODIFIER_ARM (1 << 2) +#define CL_DEVICE_SCHEDULING_DEFERRED_FLUSH_ARM (1 << 3) +#define CL_DEVICE_SCHEDULING_REGISTER_ALLOCATION_ARM (1 << 4) +#define CL_DEVICE_SCHEDULING_WARP_THROTTLING_ARM (1 << 5) +#define CL_DEVICE_SCHEDULING_COMPUTE_UNIT_BATCH_QUEUE_SIZE_ARM (1 << 6) +#define CL_DEVICE_SCHEDULING_COMPUTE_UNIT_LIMIT_ARM (1 << 7) + +/* cl_device_info */ +#define CL_DEVICE_SCHEDULING_CONTROLS_CAPABILITIES_ARM 0x41E4 +#define CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM 0x41EB +#define CL_DEVICE_MAX_WARP_COUNT_ARM 0x41EA + +/* cl_kernel_exec_info */ +#define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM 0x41E5 +#define CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM 0x41E6 +#define CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM 0x41E8 +#define CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM 0x41F1 + +/* cl_kernel_info */ +#define CL_KERNEL_MAX_WARP_COUNT_ARM 0x41E9 + +/* cl_queue_properties */ +#define CL_QUEUE_KERNEL_BATCHING_ARM 0x41E7 +#define CL_QUEUE_DEFERRED_FLUSH_ARM 0x41EC +#define CL_QUEUE_COMPUTE_UNIT_LIMIT_ARM 0x41F3 + +/*************************************************************** +* cl_arm_controlled_kernel_termination +***************************************************************/ +#define cl_arm_controlled_kernel_termination 1 +#define CL_ARM_CONTROLLED_KERNEL_TERMINATION_EXTENSION_NAME \ + "cl_arm_controlled_kernel_termination" + + +#define CL_ARM_CONTROLLED_KERNEL_TERMINATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* Types */ +typedef cl_bitfield cl_device_controlled_termination_capabilities_arm; + +/* Error codes */ +#define CL_COMMAND_TERMINATED_ITSELF_WITH_FAILURE_ARM -1108 + +/* cl_device_controlled_termination_capabilities_arm */ +#define CL_DEVICE_CONTROLLED_TERMINATION_SUCCESS_ARM (1 << 0) +#define CL_DEVICE_CONTROLLED_TERMINATION_FAILURE_ARM (1 << 1) +#define CL_DEVICE_CONTROLLED_TERMINATION_QUERY_ARM (1 << 2) + +/* cl_device_info */ +#define CL_DEVICE_CONTROLLED_TERMINATION_CAPABILITIES_ARM 0x41EE + +/* cl_event_info */ +#define CL_EVENT_COMMAND_TERMINATION_REASON_ARM 0x41ED + +/* cl_command_termination_reason_arm */ +#define CL_COMMAND_TERMINATION_COMPLETION_ARM 0 +#define CL_COMMAND_TERMINATION_CONTROLLED_SUCCESS_ARM 1 +#define CL_COMMAND_TERMINATION_CONTROLLED_FAILURE_ARM 2 +#define CL_COMMAND_TERMINATION_ERROR_ARM 3 + +/*************************************************************** +* cl_arm_protected_memory_allocation +***************************************************************/ +#define cl_arm_protected_memory_allocation 1 +#define CL_ARM_PROTECTED_MEMORY_ALLOCATION_EXTENSION_NAME \ + "cl_arm_protected_memory_allocation" + + +#define CL_ARM_PROTECTED_MEMORY_ALLOCATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +#define CL_MEM_PROTECTED_ALLOC_ARM ((cl_bitfield)1 << 36) + +/*************************************************************** +* cl_intel_exec_by_local_thread +***************************************************************/ +#define cl_intel_exec_by_local_thread 1 +#define CL_INTEL_EXEC_BY_LOCAL_THREAD_EXTENSION_NAME \ + "cl_intel_exec_by_local_thread" + + +#define CL_INTEL_EXEC_BY_LOCAL_THREAD_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_command_queue_properties - bitfield */ +#define CL_QUEUE_THREAD_LOCAL_EXEC_ENABLE_INTEL ((cl_bitfield)1 << 31) + +/*************************************************************** +* cl_intel_device_attribute_query +***************************************************************/ +#define cl_intel_device_attribute_query 1 +#define CL_INTEL_DEVICE_ATTRIBUTE_QUERY_EXTENSION_NAME \ + "cl_intel_device_attribute_query" + + +#define CL_INTEL_DEVICE_ATTRIBUTE_QUERY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef cl_bitfield cl_device_feature_capabilities_intel; + +/* cl_device_feature_capabilities_intel */ +#define CL_DEVICE_FEATURE_FLAG_DP4A_INTEL (1 << 0) +#define CL_DEVICE_FEATURE_FLAG_DPAS_INTEL (1 << 1) + +/* cl_device_info */ +#define CL_DEVICE_IP_VERSION_INTEL 0x4250 +#define CL_DEVICE_ID_INTEL 0x4251 +#define CL_DEVICE_NUM_SLICES_INTEL 0x4252 +#define CL_DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL 0x4253 +#define CL_DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL 0x4254 +#define CL_DEVICE_NUM_THREADS_PER_EU_INTEL 0x4255 +#define CL_DEVICE_FEATURE_CAPABILITIES_INTEL 0x4256 + +/*************************************************************** +* cl_intel_device_partition_by_names +***************************************************************/ +#define cl_intel_device_partition_by_names 1 +#define CL_INTEL_DEVICE_PARTITION_BY_NAMES_EXTENSION_NAME \ + "cl_intel_device_partition_by_names" + + +#define CL_INTEL_DEVICE_PARTITION_BY_NAMES_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +#define CL_DEVICE_PARTITION_BY_NAMES_INTEL 0x4052 +#define CL_PARTITION_BY_NAMES_LIST_END_INTEL -1 + +/*************************************************************** +* cl_intel_accelerator +***************************************************************/ +#define cl_intel_accelerator 1 +#define CL_INTEL_ACCELERATOR_EXTENSION_NAME \ + "cl_intel_accelerator" + + +#define CL_INTEL_ACCELERATOR_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef struct _cl_accelerator_intel* cl_accelerator_intel; +typedef cl_uint cl_accelerator_type_intel; +typedef cl_uint cl_accelerator_info_intel; + +/* cl_accelerator_info_intel */ +#define CL_ACCELERATOR_DESCRIPTOR_INTEL 0x4090 +#define CL_ACCELERATOR_REFERENCE_COUNT_INTEL 0x4091 +#define CL_ACCELERATOR_CONTEXT_INTEL 0x4092 +#define CL_ACCELERATOR_TYPE_INTEL 0x4093 + +/* Error codes */ +#define CL_INVALID_ACCELERATOR_INTEL -1094 +#define CL_INVALID_ACCELERATOR_TYPE_INTEL -1095 +#define CL_INVALID_ACCELERATOR_DESCRIPTOR_INTEL -1096 +#define CL_ACCELERATOR_TYPE_NOT_SUPPORTED_INTEL -1097 + + +typedef cl_accelerator_intel CL_API_CALL +clCreateAcceleratorINTEL_t( + cl_context context, + cl_accelerator_type_intel accelerator_type, + size_t descriptor_size, + const void* descriptor, + cl_int* errcode_ret); + +typedef clCreateAcceleratorINTEL_t * +clCreateAcceleratorINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clGetAcceleratorInfoINTEL_t( + cl_accelerator_intel accelerator, + cl_accelerator_info_intel param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetAcceleratorInfoINTEL_t * +clGetAcceleratorInfoINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clRetainAcceleratorINTEL_t( + cl_accelerator_intel accelerator); + +typedef clRetainAcceleratorINTEL_t * +clRetainAcceleratorINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clReleaseAcceleratorINTEL_t( + cl_accelerator_intel accelerator); + +typedef clReleaseAcceleratorINTEL_t * +clReleaseAcceleratorINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_accelerator_intel CL_API_CALL +clCreateAcceleratorINTEL( + cl_context context, + cl_accelerator_type_intel accelerator_type, + size_t descriptor_size, + const void* descriptor, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetAcceleratorInfoINTEL( + cl_accelerator_intel accelerator, + cl_accelerator_info_intel param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clRetainAcceleratorINTEL( + cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; + +extern CL_API_ENTRY cl_int CL_API_CALL +clReleaseAcceleratorINTEL( + cl_accelerator_intel accelerator) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_intel_motion_estimation +***************************************************************/ +#define cl_intel_motion_estimation 1 +#define CL_INTEL_MOTION_ESTIMATION_EXTENSION_NAME \ + "cl_intel_motion_estimation" + + +#define CL_INTEL_MOTION_ESTIMATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef struct _cl_motion_estimation_desc_intel { + cl_uint mb_block_type; + cl_uint subpixel_mode; + cl_uint sad_adjust_mode; + cl_uint search_path_type; +} cl_motion_estimation_desc_intel; + +/* cl_accelerator_type_intel */ +#define CL_ACCELERATOR_TYPE_MOTION_ESTIMATION_INTEL 0x0 + +/* cl_uint mb_block_type */ +#define CL_ME_MB_TYPE_16x16_INTEL 0x0 +#define CL_ME_MB_TYPE_8x8_INTEL 0x1 +#define CL_ME_MB_TYPE_4x4_INTEL 0x2 + +/* cl_uint subpixel_mode */ +#define CL_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 +#define CL_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 +#define CL_ME_SUBPIXEL_MODE_QPEL_INTEL 0x2 + +/* cl_uint sad_adjust_mode */ +#define CL_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 +#define CL_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x1 + +/* cl_uint search_path_type */ +#define CL_ME_SEARCH_PATH_RADIUS_2_2_INTEL 0x0 +#define CL_ME_SEARCH_PATH_RADIUS_4_4_INTEL 0x1 +#define CL_ME_SEARCH_PATH_RADIUS_16_12_INTEL 0x5 + +/*************************************************************** +* cl_intel_advanced_motion_estimation +***************************************************************/ +#define cl_intel_advanced_motion_estimation 1 +#define CL_INTEL_ADVANCED_MOTION_ESTIMATION_EXTENSION_NAME \ + "cl_intel_advanced_motion_estimation" + + +#define CL_INTEL_ADVANCED_MOTION_ESTIMATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_ME_VERSION_INTEL 0x407E + +#define CL_ME_VERSION_LEGACY_INTEL 0x0 +#define CL_ME_VERSION_ADVANCED_VER_1_INTEL 0x1 +#define CL_ME_VERSION_ADVANCED_VER_2_INTEL 0x2 + +#define CL_ME_CHROMA_INTRA_PREDICT_ENABLED_INTEL 0x1 +#define CL_ME_LUMA_INTRA_PREDICT_ENABLED_INTEL 0x2 + +#define CL_ME_SKIP_BLOCK_TYPE_16x16_INTEL 0x0 +#define CL_ME_SKIP_BLOCK_TYPE_8x8_INTEL 0x4 + +#define CL_ME_COST_PENALTY_NONE_INTEL 0x0 +#define CL_ME_COST_PENALTY_LOW_INTEL 0x1 +#define CL_ME_COST_PENALTY_NORMAL_INTEL 0x2 +#define CL_ME_COST_PENALTY_HIGH_INTEL 0x3 + +#define CL_ME_COST_PRECISION_QPEL_INTEL 0x0 +#define CL_ME_COST_PRECISION_HPEL_INTEL 0x1 +#define CL_ME_COST_PRECISION_PEL_INTEL 0x2 +#define CL_ME_COST_PRECISION_DPEL_INTEL 0x3 + +#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 +#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 +#define CL_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 +#define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 +#define CL_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 +#define CL_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 +#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 +#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 +#define CL_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 +#define CL_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 + +#define CL_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 +#define CL_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 +#define CL_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 +#define CL_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 + +#define CL_ME_FORWARD_INPUT_MODE_INTEL 0x1 +#define CL_ME_BACKWARD_INPUT_MODE_INTEL 0x2 +#define CL_ME_BIDIRECTION_INPUT_MODE_INTEL 0x3 + +#define CL_ME_BIDIR_WEIGHT_QUARTER_INTEL 16 +#define CL_ME_BIDIR_WEIGHT_THIRD_INTEL 21 +#define CL_ME_BIDIR_WEIGHT_HALF_INTEL 32 +#define CL_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 43 +#define CL_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 48 + +/*************************************************************** +* cl_intel_simultaneous_sharing +***************************************************************/ +#define cl_intel_simultaneous_sharing 1 +#define CL_INTEL_SIMULTANEOUS_SHARING_EXTENSION_NAME \ + "cl_intel_simultaneous_sharing" + + +#define CL_INTEL_SIMULTANEOUS_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_SIMULTANEOUS_INTEROPS_INTEL 0x4104 +#define CL_DEVICE_NUM_SIMULTANEOUS_INTEROPS_INTEL 0x4105 + +/*************************************************************** +* cl_intel_egl_image_yuv +***************************************************************/ +#define cl_intel_egl_image_yuv 1 +#define CL_INTEL_EGL_IMAGE_YUV_EXTENSION_NAME \ + "cl_intel_egl_image_yuv" + + +#define CL_INTEL_EGL_IMAGE_YUV_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_egl_image_properties_khr */ +#define CL_EGL_YUV_PLANE_INTEL 0x4107 + +/*************************************************************** +* cl_intel_packed_yuv +***************************************************************/ +#define cl_intel_packed_yuv 1 +#define CL_INTEL_PACKED_YUV_EXTENSION_NAME \ + "cl_intel_packed_yuv" + + +#define CL_INTEL_PACKED_YUV_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_channel_order */ +#define CL_YUYV_INTEL 0x4076 +#define CL_UYVY_INTEL 0x4077 +#define CL_YVYU_INTEL 0x4078 +#define CL_VYUY_INTEL 0x4079 + +/*************************************************************** +* cl_intel_required_subgroup_size +***************************************************************/ +#define cl_intel_required_subgroup_size 1 +#define CL_INTEL_REQUIRED_SUBGROUP_SIZE_EXTENSION_NAME \ + "cl_intel_required_subgroup_size" + + +#define CL_INTEL_REQUIRED_SUBGROUP_SIZE_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_SUB_GROUP_SIZES_INTEL 0x4108 + +/* cl_kernel_work_group_info */ +#define CL_KERNEL_SPILL_MEM_SIZE_INTEL 0x4109 + +/* cl_kernel_sub_group_info */ +#define CL_KERNEL_COMPILE_SUB_GROUP_SIZE_INTEL 0x410A + +/*************************************************************** +* cl_intel_driver_diagnostics +***************************************************************/ +#define cl_intel_driver_diagnostics 1 +#define CL_INTEL_DRIVER_DIAGNOSTICS_EXTENSION_NAME \ + "cl_intel_driver_diagnostics" + + +#define CL_INTEL_DRIVER_DIAGNOSTICS_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef cl_bitfield cl_diagnostic_verbose_level_intel; + +/* cl_context_properties */ +#define CL_CONTEXT_SHOW_DIAGNOSTICS_INTEL 0x4106 + +/* cl_diagnostic_verbose_level_intel */ +#define CL_CONTEXT_DIAGNOSTICS_LEVEL_ALL_INTEL 0xff +#define CL_CONTEXT_DIAGNOSTICS_LEVEL_GOOD_INTEL (1 << 0) +#define CL_CONTEXT_DIAGNOSTICS_LEVEL_BAD_INTEL (1 << 1) +#define CL_CONTEXT_DIAGNOSTICS_LEVEL_NEUTRAL_INTEL (1 << 2) + +/*************************************************************** +* cl_intel_planar_yuv +***************************************************************/ +#define cl_intel_planar_yuv 1 +#define CL_INTEL_PLANAR_YUV_EXTENSION_NAME \ + "cl_intel_planar_yuv" + + +#define CL_INTEL_PLANAR_YUV_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_channel_order */ +#define CL_NV12_INTEL 0x410E + +/* cl_mem_flags */ +#define CL_MEM_NO_ACCESS_INTEL (1 << 24) +#define CL_MEM_ACCESS_FLAGS_UNRESTRICTED_INTEL (1 << 25) + +/* cl_device_info */ +#define CL_DEVICE_PLANAR_YUV_MAX_WIDTH_INTEL 0x417E +#define CL_DEVICE_PLANAR_YUV_MAX_HEIGHT_INTEL 0x417F + +/*************************************************************** +* cl_intel_device_side_avc_motion_estimation +***************************************************************/ +#define cl_intel_device_side_avc_motion_estimation 1 +#define CL_INTEL_DEVICE_SIDE_AVC_MOTION_ESTIMATION_EXTENSION_NAME \ + "cl_intel_device_side_avc_motion_estimation" + + +#define CL_INTEL_DEVICE_SIDE_AVC_MOTION_ESTIMATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_device_info */ +#define CL_DEVICE_AVC_ME_VERSION_INTEL 0x410B +#define CL_DEVICE_AVC_ME_SUPPORTS_TEXTURE_SAMPLER_USE_INTEL 0x410C +#define CL_DEVICE_AVC_ME_SUPPORTS_PREEMPTION_INTEL 0x410D + +/* returned by CL_DEVICE_AVC_ME_VERSION_INTEL */ +#define CL_AVC_ME_VERSION_0_INTEL 0x0 +#define CL_AVC_ME_VERSION_1_INTEL 0x1 + +/* Inter macro-block major shape values */ +#define CL_AVC_ME_MAJOR_16x16_INTEL 0x0 +#define CL_AVC_ME_MAJOR_16x8_INTEL 0x1 +#define CL_AVC_ME_MAJOR_8x16_INTEL 0x2 +#define CL_AVC_ME_MAJOR_8x8_INTEL 0x3 + +/* Inter macro-block minor shape values */ +#define CL_AVC_ME_MINOR_8x8_INTEL 0x0 +#define CL_AVC_ME_MINOR_8x4_INTEL 0x1 +#define CL_AVC_ME_MINOR_4x8_INTEL 0x2 +#define CL_AVC_ME_MINOR_4x4_INTEL 0x3 + +/* Inter macro-block major direction values */ +#define CL_AVC_ME_MAJOR_FORWARD_INTEL 0x0 +#define CL_AVC_ME_MAJOR_BACKWARD_INTEL 0x1 +#define CL_AVC_ME_MAJOR_BIDIRECTIONAL_INTEL 0x2 + +/* Inter (IME) partition mask values */ +#define CL_AVC_ME_PARTITION_MASK_ALL_INTEL 0x0 +#define CL_AVC_ME_PARTITION_MASK_16x16_INTEL 0x7E +#define CL_AVC_ME_PARTITION_MASK_16x8_INTEL 0x7D +#define CL_AVC_ME_PARTITION_MASK_8x16_INTEL 0x7B +#define CL_AVC_ME_PARTITION_MASK_8x8_INTEL 0x77 +#define CL_AVC_ME_PARTITION_MASK_8x4_INTEL 0x6F +#define CL_AVC_ME_PARTITION_MASK_4x8_INTEL 0x5F +#define CL_AVC_ME_PARTITION_MASK_4x4_INTEL 0x3F + +/* Search window configuration */ +#define CL_AVC_ME_SEARCH_WINDOW_EXHAUSTIVE_INTEL 0x0 +#define CL_AVC_ME_SEARCH_WINDOW_SMALL_INTEL 0x1 +#define CL_AVC_ME_SEARCH_WINDOW_TINY_INTEL 0x2 +#define CL_AVC_ME_SEARCH_WINDOW_EXTRA_TINY_INTEL 0x3 +#define CL_AVC_ME_SEARCH_WINDOW_DIAMOND_INTEL 0x4 +#define CL_AVC_ME_SEARCH_WINDOW_LARGE_DIAMOND_INTEL 0x5 +#define CL_AVC_ME_SEARCH_WINDOW_RESERVED0_INTEL 0x6 +#define CL_AVC_ME_SEARCH_WINDOW_RESERVED1_INTEL 0x7 +#define CL_AVC_ME_SEARCH_WINDOW_CUSTOM_INTEL 0x8 +#define CL_AVC_ME_SEARCH_WINDOW_16x12_RADIUS_INTEL 0x9 +#define CL_AVC_ME_SEARCH_WINDOW_4x4_RADIUS_INTEL 0x2 +#define CL_AVC_ME_SEARCH_WINDOW_2x2_RADIUS_INTEL 0xa + +/* SAD adjustment mode */ +#define CL_AVC_ME_SAD_ADJUST_MODE_NONE_INTEL 0x0 +#define CL_AVC_ME_SAD_ADJUST_MODE_HAAR_INTEL 0x2 + +/* Pixel resolution */ +#define CL_AVC_ME_SUBPIXEL_MODE_INTEGER_INTEL 0x0 +#define CL_AVC_ME_SUBPIXEL_MODE_HPEL_INTEL 0x1 +#define CL_AVC_ME_SUBPIXEL_MODE_QPEL_INTEL 0x3 + +/* Cost precision values */ +#define CL_AVC_ME_COST_PRECISION_QPEL_INTEL 0x0 +#define CL_AVC_ME_COST_PRECISION_HPEL_INTEL 0x1 +#define CL_AVC_ME_COST_PRECISION_PEL_INTEL 0x2 +#define CL_AVC_ME_COST_PRECISION_DPEL_INTEL 0x3 + +/* Inter bidirectional weights */ +#define CL_AVC_ME_BIDIR_WEIGHT_QUARTER_INTEL 0x10 +#define CL_AVC_ME_BIDIR_WEIGHT_THIRD_INTEL 0x15 +#define CL_AVC_ME_BIDIR_WEIGHT_HALF_INTEL 0x20 +#define CL_AVC_ME_BIDIR_WEIGHT_TWO_THIRD_INTEL 0x2B +#define CL_AVC_ME_BIDIR_WEIGHT_THREE_QUARTER_INTEL 0x30 + +/* Inter border reached values */ +#define CL_AVC_ME_BORDER_REACHED_LEFT_INTEL 0x0 +#define CL_AVC_ME_BORDER_REACHED_RIGHT_INTEL 0x2 +#define CL_AVC_ME_BORDER_REACHED_TOP_INTEL 0x4 +#define CL_AVC_ME_BORDER_REACHED_BOTTOM_INTEL 0x8 + +/* Inter skip block partition type */ +#define CL_AVC_ME_SKIP_BLOCK_PARTITION_16x16_INTEL 0x0 +#define CL_AVC_ME_SKIP_BLOCK_PARTITION_8x8_INTEL 0x4000 + +/* Inter skip motion vector mask */ +#define CL_AVC_ME_SKIP_BLOCK_16x16_FORWARD_ENABLE_INTEL (0x1 << 24) +#define CL_AVC_ME_SKIP_BLOCK_16x16_BACKWARD_ENABLE_INTEL (0x2 << 24) +#define CL_AVC_ME_SKIP_BLOCK_16x16_DUAL_ENABLE_INTEL (0x3 << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_FORWARD_ENABLE_INTEL (0x55 << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_BACKWARD_ENABLE_INTEL (0xAA << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_DUAL_ENABLE_INTEL (0xFF << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_0_FORWARD_ENABLE_INTEL (0x1 << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_0_BACKWARD_ENABLE_INTEL (0x2 << 24) +#define CL_AVC_ME_SKIP_BLOCK_8x8_1_FORWARD_ENABLE_INTEL (0x1 << 26) +#define CL_AVC_ME_SKIP_BLOCK_8x8_1_BACKWARD_ENABLE_INTEL (0x2 << 26) +#define CL_AVC_ME_SKIP_BLOCK_8x8_2_FORWARD_ENABLE_INTEL (0x1 << 28) +#define CL_AVC_ME_SKIP_BLOCK_8x8_2_BACKWARD_ENABLE_INTEL (0x2 << 28) +#define CL_AVC_ME_SKIP_BLOCK_8x8_3_FORWARD_ENABLE_INTEL (0x1 << 30) +#define CL_AVC_ME_SKIP_BLOCK_8x8_3_BACKWARD_ENABLE_INTEL (0x2 << 30) + +/* Block based skip type values */ +#define CL_AVC_ME_BLOCK_BASED_SKIP_4x4_INTEL 0x00 +#define CL_AVC_ME_BLOCK_BASED_SKIP_8x8_INTEL 0x80 + +/* cl_intel_device_side_avc_motion_estimation.?? */ +#define CL_AVC_ME_INTRA_16x16_INTEL 0x0 +#define CL_AVC_ME_INTRA_8x8_INTEL 0x1 +#define CL_AVC_ME_INTRA_4x4_INTEL 0x2 + +/* Luma intra partition mask values */ +#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_16x16_INTEL 0x6 +#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_8x8_INTEL 0x5 +#define CL_AVC_ME_INTRA_LUMA_PARTITION_MASK_4x4_INTEL 0x3 + +/* Intra neighbor availability mask values */ +#define CL_AVC_ME_INTRA_NEIGHBOR_LEFT_MASK_ENABLE_INTEL 0x60 +#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_MASK_ENABLE_INTEL 0x10 +#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_RIGHT_MASK_ENABLE_INTEL 0x8 +#define CL_AVC_ME_INTRA_NEIGHBOR_UPPER_LEFT_MASK_ENABLE_INTEL 0x4 + +/* Luma intra modes */ +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_INTEL 0x0 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DC_INTEL 0x2 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_LEFT_INTEL 0x3 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_DIAGONAL_DOWN_RIGHT_INTEL 0x4 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_PLANE_INTEL 0x4 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_RIGHT_INTEL 0x5 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_DOWN_INTEL 0x6 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_VERTICAL_LEFT_INTEL 0x7 +#define CL_AVC_ME_LUMA_PREDICTOR_MODE_HORIZONTAL_UP_INTEL 0x8 + +/* Chroma intra modes */ +#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_DC_INTEL 0x0 +#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_HORIZONTAL_INTEL 0x1 +#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_VERTICAL_INTEL 0x2 +#define CL_AVC_ME_CHROMA_PREDICTOR_MODE_PLANE_INTEL 0x3 + +/* Reference image select values */ +#define CL_AVC_ME_FRAME_FORWARD_INTEL 0x1 +#define CL_AVC_ME_FRAME_BACKWARD_INTEL 0x2 +#define CL_AVC_ME_FRAME_DUAL_INTEL 0x3 + +/* Slice type values */ +#define CL_AVC_ME_SLICE_TYPE_PRED_INTEL 0x0 +#define CL_AVC_ME_SLICE_TYPE_BPRED_INTEL 0x1 +#define CL_AVC_ME_SLICE_TYPE_INTRA_INTEL 0x2 + +/* Interlaced image field polarity values */ +#define CL_AVC_ME_INTERLACED_SCAN_TOP_FIELD_INTEL 0x0 +#define CL_AVC_ME_INTERLACED_SCAN_BOTTOM_FIELD_INTEL 0x1 + +/*************************************************************** +* cl_intel_unified_shared_memory +***************************************************************/ +#define cl_intel_unified_shared_memory 1 +#define CL_INTEL_UNIFIED_SHARED_MEMORY_EXTENSION_NAME \ + "cl_intel_unified_shared_memory" + + +#define CL_INTEL_UNIFIED_SHARED_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef cl_bitfield cl_device_unified_shared_memory_capabilities_intel; +typedef cl_properties cl_mem_properties_intel; +typedef cl_bitfield cl_mem_alloc_flags_intel; +typedef cl_uint cl_mem_info_intel; +typedef cl_uint cl_unified_shared_memory_type_intel; +typedef cl_uint cl_mem_advice_intel; + +/* cl_device_info */ +#define CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL 0x4190 +#define CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL 0x4191 +#define CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4192 +#define CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL 0x4193 +#define CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL 0x4194 + +/* cl_unified_shared_memory_capabilities_intel - bitfield */ +#define CL_UNIFIED_SHARED_MEMORY_ACCESS_INTEL (1 << 0) +#define CL_UNIFIED_SHARED_MEMORY_ATOMIC_ACCESS_INTEL (1 << 1) +#define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ACCESS_INTEL (1 << 2) +#define CL_UNIFIED_SHARED_MEMORY_CONCURRENT_ATOMIC_ACCESS_INTEL (1 << 3) + +/* cl_mem_properties_intel */ +#define CL_MEM_ALLOC_FLAGS_INTEL 0x4195 + +/* cl_mem_alloc_flags_intel - bitfield */ +#define CL_MEM_ALLOC_WRITE_COMBINED_INTEL (1 << 0) +#define CL_MEM_ALLOC_INITIAL_PLACEMENT_DEVICE_INTEL (1 << 1) +#define CL_MEM_ALLOC_INITIAL_PLACEMENT_HOST_INTEL (1 << 2) + +/* cl_mem_alloc_info_intel */ +#define CL_MEM_ALLOC_TYPE_INTEL 0x419A +#define CL_MEM_ALLOC_BASE_PTR_INTEL 0x419B +#define CL_MEM_ALLOC_SIZE_INTEL 0x419C +#define CL_MEM_ALLOC_DEVICE_INTEL 0x419D + +/* cl_unified_shared_memory_type_intel */ +#define CL_MEM_TYPE_UNKNOWN_INTEL 0x4196 +#define CL_MEM_TYPE_HOST_INTEL 0x4197 +#define CL_MEM_TYPE_DEVICE_INTEL 0x4198 +#define CL_MEM_TYPE_SHARED_INTEL 0x4199 + +/* cl_kernel_exec_info */ +#define CL_KERNEL_EXEC_INFO_INDIRECT_HOST_ACCESS_INTEL 0x4200 +#define CL_KERNEL_EXEC_INFO_INDIRECT_DEVICE_ACCESS_INTEL 0x4201 +#define CL_KERNEL_EXEC_INFO_INDIRECT_SHARED_ACCESS_INTEL 0x4202 +#define CL_KERNEL_EXEC_INFO_USM_PTRS_INTEL 0x4203 + +/* cl_command_type */ +#define CL_COMMAND_MEMFILL_INTEL 0x4204 +#define CL_COMMAND_MEMCPY_INTEL 0x4205 +#define CL_COMMAND_MIGRATEMEM_INTEL 0x4206 +#define CL_COMMAND_MEMADVISE_INTEL 0x4207 + + +typedef void* CL_API_CALL +clHostMemAllocINTEL_t( + cl_context context, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret); + +typedef clHostMemAllocINTEL_t * +clHostMemAllocINTEL_fn ; + +typedef void* CL_API_CALL +clDeviceMemAllocINTEL_t( + cl_context context, + cl_device_id device, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret); + +typedef clDeviceMemAllocINTEL_t * +clDeviceMemAllocINTEL_fn ; + +typedef void* CL_API_CALL +clSharedMemAllocINTEL_t( + cl_context context, + cl_device_id device, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret); + +typedef clSharedMemAllocINTEL_t * +clSharedMemAllocINTEL_fn ; + +typedef cl_int CL_API_CALL +clMemFreeINTEL_t( + cl_context context, + void* ptr); + +typedef clMemFreeINTEL_t * +clMemFreeINTEL_fn ; + +typedef cl_int CL_API_CALL +clMemBlockingFreeINTEL_t( + cl_context context, + void* ptr); + +typedef clMemBlockingFreeINTEL_t * +clMemBlockingFreeINTEL_fn ; + +typedef cl_int CL_API_CALL +clGetMemAllocInfoINTEL_t( + cl_context context, + const void* ptr, + cl_mem_info_intel param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetMemAllocInfoINTEL_t * +clGetMemAllocInfoINTEL_fn ; + +typedef cl_int CL_API_CALL +clSetKernelArgMemPointerINTEL_t( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value); + +typedef clSetKernelArgMemPointerINTEL_t * +clSetKernelArgMemPointerINTEL_fn ; + +typedef cl_int CL_API_CALL +clEnqueueMemFillINTEL_t( + cl_command_queue command_queue, + void* dst_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMemFillINTEL_t * +clEnqueueMemFillINTEL_fn ; + +typedef cl_int CL_API_CALL +clEnqueueMemcpyINTEL_t( + cl_command_queue command_queue, + cl_bool blocking, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMemcpyINTEL_t * +clEnqueueMemcpyINTEL_fn ; + +typedef cl_int CL_API_CALL +clEnqueueMemAdviseINTEL_t( + cl_command_queue command_queue, + const void* ptr, + size_t size, + cl_mem_advice_intel advice, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMemAdviseINTEL_t * +clEnqueueMemAdviseINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY void* CL_API_CALL +clHostMemAllocINTEL( + cl_context context, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret) ; + +extern CL_API_ENTRY void* CL_API_CALL +clDeviceMemAllocINTEL( + cl_context context, + cl_device_id device, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret) ; + +extern CL_API_ENTRY void* CL_API_CALL +clSharedMemAllocINTEL( + cl_context context, + cl_device_id device, + const cl_mem_properties_intel* properties, + size_t size, + cl_uint alignment, + cl_int* errcode_ret) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clMemFreeINTEL( + cl_context context, + void* ptr) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clMemBlockingFreeINTEL( + cl_context context, + void* ptr) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetMemAllocInfoINTEL( + cl_context context, + const void* ptr, + cl_mem_info_intel param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetKernelArgMemPointerINTEL( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMemFillINTEL( + cl_command_queue command_queue, + void* dst_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMemcpyINTEL( + cl_command_queue command_queue, + cl_bool blocking, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) ; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMemAdviseINTEL( + cl_command_queue command_queue, + const void* ptr, + size_t size, + cl_mem_advice_intel advice, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +#if defined(CL_VERSION_1_2) +/* Requires OpenCL 1.2 for cl_mem_migration_flags: */ + +typedef cl_int CL_API_CALL +clEnqueueMigrateMemINTEL_t( + cl_command_queue command_queue, + const void* ptr, + size_t size, + cl_mem_migration_flags flags, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMigrateMemINTEL_t * +clEnqueueMigrateMemINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMigrateMemINTEL( + cl_command_queue command_queue, + const void* ptr, + size_t size, + cl_mem_migration_flags flags, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +#endif /* defined(CL_VERSION_1_2) */ + +/* deprecated, use clEnqueueMemFillINTEL instead */ + +typedef cl_int CL_API_CALL +clEnqueueMemsetINTEL_t( + cl_command_queue command_queue, + void* dst_ptr, + cl_int value, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMemsetINTEL_t * +clEnqueueMemsetINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueMemsetINTEL( + cl_command_queue command_queue, + void* dst_ptr, + cl_int value, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_intel_mem_alloc_buffer_location +***************************************************************/ +#define cl_intel_mem_alloc_buffer_location 1 +#define CL_INTEL_MEM_ALLOC_BUFFER_LOCATION_EXTENSION_NAME \ + "cl_intel_mem_alloc_buffer_location" + + +#define CL_INTEL_MEM_ALLOC_BUFFER_LOCATION_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_mem_properties_intel */ +#define CL_MEM_ALLOC_BUFFER_LOCATION_INTEL 0x419E + +/* cl_mem_alloc_info_intel */ +/* enum CL_MEM_ALLOC_BUFFER_LOCATION_INTEL */ + +/*************************************************************** +* cl_intel_create_buffer_with_properties +***************************************************************/ +#define cl_intel_create_buffer_with_properties 1 +#define CL_INTEL_CREATE_BUFFER_WITH_PROPERTIES_EXTENSION_NAME \ + "cl_intel_create_buffer_with_properties" + + +#define CL_INTEL_CREATE_BUFFER_WITH_PROPERTIES_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* type cl_mem_properties_intel */ + + +typedef cl_mem CL_API_CALL +clCreateBufferWithPropertiesINTEL_t( + cl_context context, + const cl_mem_properties_intel* properties, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateBufferWithPropertiesINTEL_t * +clCreateBufferWithPropertiesINTEL_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateBufferWithPropertiesINTEL( + cl_context context, + const cl_mem_properties_intel* properties, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_intel_program_scope_host_pipe +***************************************************************/ +#define cl_intel_program_scope_host_pipe 1 +#define CL_INTEL_PROGRAM_SCOPE_HOST_PIPE_EXTENSION_NAME \ + "cl_intel_program_scope_host_pipe" + + +#define CL_INTEL_PROGRAM_SCOPE_HOST_PIPE_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* clGetEventInfo response when param_name is CL_EVENT_COMMAND_TYPE */ +#define CL_COMMAND_READ_HOST_PIPE_INTEL 0x4214 +#define CL_COMMAND_WRITE_HOST_PIPE_INTEL 0x4215 + +/* clGetProgramInfo param_name */ +#define CL_PROGRAM_NUM_HOST_PIPES_INTEL 0x4216 +#define CL_PROGRAM_HOST_PIPE_NAMES_INTEL 0x4217 + + +typedef cl_int CL_API_CALL +clEnqueueReadHostPipeINTEL_t( + cl_command_queue command_queue, + cl_program program, + const char* pipe_symbol, + cl_bool blocking_read, + void* ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReadHostPipeINTEL_t * +clEnqueueReadHostPipeINTEL_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueWriteHostPipeINTEL_t( + cl_command_queue command_queue, + cl_program program, + const char* pipe_symbol, + cl_bool blocking_write, + const void* ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueWriteHostPipeINTEL_t * +clEnqueueWriteHostPipeINTEL_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueReadHostPipeINTEL( + cl_command_queue command_queue, + cl_program program, + const char* pipe_symbol, + cl_bool blocking_read, + void* ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + +extern CL_API_ENTRY cl_int CL_API_CALL +clEnqueueWriteHostPipeINTEL( + cl_command_queue command_queue, + cl_program program, + const char* pipe_symbol, + cl_bool blocking_write, + const void* ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_intel_mem_channel_property +***************************************************************/ +#define cl_intel_mem_channel_property 1 +#define CL_INTEL_MEM_CHANNEL_PROPERTY_EXTENSION_NAME \ + "cl_intel_mem_channel_property" + + +#define CL_INTEL_MEM_CHANNEL_PROPERTY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_mem_properties_intel */ +#define CL_MEM_CHANNEL_INTEL 0x4213 + +/*************************************************************** +* cl_intel_mem_force_host_memory +***************************************************************/ +#define cl_intel_mem_force_host_memory 1 +#define CL_INTEL_MEM_FORCE_HOST_MEMORY_EXTENSION_NAME \ + "cl_intel_mem_force_host_memory" + + +#define CL_INTEL_MEM_FORCE_HOST_MEMORY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_mem_flags */ +#define CL_MEM_FORCE_HOST_MEMORY_INTEL (1 << 20) + +/*************************************************************** +* cl_intel_command_queue_families +***************************************************************/ +#define cl_intel_command_queue_families 1 +#define CL_INTEL_COMMAND_QUEUE_FAMILIES_EXTENSION_NAME \ + "cl_intel_command_queue_families" + + +#define CL_INTEL_COMMAND_QUEUE_FAMILIES_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +typedef cl_bitfield cl_command_queue_capabilities_intel; + +#define CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL 64 + +typedef struct _cl_queue_family_properties_intel { + cl_command_queue_properties properties; + cl_command_queue_capabilities_intel capabilities; + cl_uint count; + char name[CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL]; +} cl_queue_family_properties_intel; + +/* cl_device_info */ +#define CL_DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL 0x418B + +/* cl_queue_properties */ +#define CL_QUEUE_FAMILY_INTEL 0x418C +#define CL_QUEUE_INDEX_INTEL 0x418D + +/* cl_command_queue_capabilities_intel */ +#define CL_QUEUE_DEFAULT_CAPABILITIES_INTEL 0 +#define CL_QUEUE_CAPABILITY_CREATE_SINGLE_QUEUE_EVENTS_INTEL (1 << 0) +#define CL_QUEUE_CAPABILITY_CREATE_CROSS_QUEUE_EVENTS_INTEL (1 << 1) +#define CL_QUEUE_CAPABILITY_SINGLE_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 2) +#define CL_QUEUE_CAPABILITY_CROSS_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 3) +#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL (1 << 8) +#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL (1 << 9) +#define CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL (1 << 10) +#define CL_QUEUE_CAPABILITY_FILL_BUFFER_INTEL (1 << 11) +#define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_INTEL (1 << 12) +#define CL_QUEUE_CAPABILITY_MAP_IMAGE_INTEL (1 << 13) +#define CL_QUEUE_CAPABILITY_FILL_IMAGE_INTEL (1 << 14) +#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_IMAGE_INTEL (1 << 15) +#define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_BUFFER_INTEL (1 << 16) +#define CL_QUEUE_CAPABILITY_MARKER_INTEL (1 << 24) +#define CL_QUEUE_CAPABILITY_BARRIER_INTEL (1 << 25) +#define CL_QUEUE_CAPABILITY_KERNEL_INTEL (1 << 26) + +/*************************************************************** +* cl_intel_queue_no_sync_operations +***************************************************************/ +#define cl_intel_queue_no_sync_operations 1 +#define CL_INTEL_QUEUE_NO_SYNC_OPERATIONS_EXTENSION_NAME \ + "cl_intel_queue_no_sync_operations" + + +#define CL_INTEL_QUEUE_NO_SYNC_OPERATIONS_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_command_queue_properties */ +#define CL_QUEUE_NO_SYNC_OPERATIONS_INTEL (1 << 29) + +/*************************************************************** +* cl_intel_sharing_format_query +***************************************************************/ +#define cl_intel_sharing_format_query 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_EXTENSION_NAME \ + "cl_intel_sharing_format_query" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/*************************************************************** +* cl_ext_image_requirements_info +***************************************************************/ +#if defined(CL_VERSION_3_0) + +#define cl_ext_image_requirements_info 1 +#define CL_EXT_IMAGE_REQUIREMENTS_INFO_EXTENSION_NAME \ + "cl_ext_image_requirements_info" + + +#define CL_EXT_IMAGE_REQUIREMENTS_INFO_EXTENSION_VERSION CL_MAKE_VERSION(0, 5, 0) + +/* Types */ +typedef cl_uint cl_image_requirements_info_ext; + +/* cl_image_requirements_info_ext */ +#define CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT 0x1292 +#define CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT 0x1290 +#define CL_IMAGE_REQUIREMENTS_SIZE_EXT 0x12B2 +#define CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT 0x12B3 +#define CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT 0x12B4 +#define CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT 0x12B5 +#define CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT 0x12B6 + +/* Enqueued Commands APIs */ + +typedef cl_int CL_API_CALL +clGetImageRequirementsInfoEXT_t( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + const cl_image_format* image_format, + const cl_image_desc* image_desc, + cl_image_requirements_info_ext param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetImageRequirementsInfoEXT_t * +clGetImageRequirementsInfoEXT_fn CL_API_SUFFIX__VERSION_3_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetImageRequirementsInfoEXT( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + const cl_image_format* image_format, + const cl_image_desc* image_desc, + cl_image_requirements_info_ext param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_3_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +#endif /* defined(CL_VERSION_3_0) */ + +/*************************************************************** +* cl_ext_image_from_buffer +***************************************************************/ +#if defined(CL_VERSION_3_0) + +#define cl_ext_image_from_buffer 1 +#define CL_EXT_IMAGE_FROM_BUFFER_EXTENSION_NAME \ + "cl_ext_image_from_buffer" + + +#define CL_EXT_IMAGE_FROM_BUFFER_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* cl_image_requirements_info_ext */ +#define CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT 0x1291 + +#endif /* defined(CL_VERSION_3_0) */ + +/*************************************************************** +* cl_loader_info +***************************************************************/ +#define cl_loader_info 1 +#define CL_LOADER_INFO_EXTENSION_NAME \ + "cl_loader_info" + + +#define CL_LOADER_INFO_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_uint cl_icdl_info; + +/* cl_icdl_info */ +#define CL_ICDL_OCL_VERSION 1 +#define CL_ICDL_VERSION 2 +#define CL_ICDL_NAME 3 +#define CL_ICDL_VENDOR 4 + + +typedef cl_int CL_API_CALL +clGetICDLoaderInfoOCLICD_t( + cl_icdl_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetICDLoaderInfoOCLICD_t * +clGetICDLoaderInfoOCLICD_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetICDLoaderInfoOCLICD( + cl_icdl_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_khr_depth_images +***************************************************************/ +#define cl_khr_depth_images 1 +#define CL_KHR_DEPTH_IMAGES_EXTENSION_NAME \ + "cl_khr_depth_images" + + +#define CL_KHR_DEPTH_IMAGES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +#if !defined(CL_VERSION_2_0) +/* cl_channel_order - defined in CL.h for OpenCL 2.0 and newer */ +#define CL_DEPTH 0x10BD + +#endif /* !defined(CL_VERSION_2_0) */ + +/*************************************************************** +* cl_ext_float_atomics +***************************************************************/ +#define cl_ext_float_atomics 1 +#define CL_EXT_FLOAT_ATOMICS_EXTENSION_NAME \ + "cl_ext_float_atomics" + + +#define CL_EXT_FLOAT_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_bitfield cl_device_fp_atomic_capabilities_ext; + +/* cl_device_fp_atomic_capabilities_ext */ +#define CL_DEVICE_GLOBAL_FP_ATOMIC_LOAD_STORE_EXT (1 << 0) +#define CL_DEVICE_GLOBAL_FP_ATOMIC_ADD_EXT (1 << 1) +#define CL_DEVICE_GLOBAL_FP_ATOMIC_MIN_MAX_EXT (1 << 2) +#define CL_DEVICE_LOCAL_FP_ATOMIC_LOAD_STORE_EXT (1 << 16) +#define CL_DEVICE_LOCAL_FP_ATOMIC_ADD_EXT (1 << 17) +#define CL_DEVICE_LOCAL_FP_ATOMIC_MIN_MAX_EXT (1 << 18) + +/* cl_device_info */ +#define CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT 0x4231 +#define CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT 0x4232 +#define CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT 0x4233 + +/*************************************************************** +* cl_intel_create_mem_object_properties +***************************************************************/ +#define cl_intel_create_mem_object_properties 1 +#define CL_INTEL_CREATE_MEM_OBJECT_PROPERTIES_EXTENSION_NAME \ + "cl_intel_create_mem_object_properties" + + +#define CL_INTEL_CREATE_MEM_OBJECT_PROPERTIES_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* cl_mem_properties */ +#define CL_MEM_LOCALLY_UNCACHED_RESOURCE_INTEL 0x4218 +#define CL_MEM_DEVICE_ID_INTEL 0x4219 + +/*************************************************************** +* cl_pocl_content_size +***************************************************************/ +#define cl_pocl_content_size 1 +#define CL_POCL_CONTENT_SIZE_EXTENSION_NAME \ + "cl_pocl_content_size" + + +#define CL_POCL_CONTENT_SIZE_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + + +typedef cl_int CL_API_CALL +clSetContentSizeBufferPoCL_t( + cl_mem buffer, + cl_mem content_size_buffer); + +typedef clSetContentSizeBufferPoCL_t * +clSetContentSizeBufferPoCL_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clSetContentSizeBufferPoCL( + cl_mem buffer, + cl_mem content_size_buffer) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_ext_image_raw10_raw12 +***************************************************************/ +#define cl_ext_image_raw10_raw12 1 +#define CL_EXT_IMAGE_RAW10_RAW12_EXTENSION_NAME \ + "cl_ext_image_raw10_raw12" + + +#define CL_EXT_IMAGE_RAW10_RAW12_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* cl_channel_type */ +#define CL_UNSIGNED_INT_RAW10_EXT 0x10E3 +#define CL_UNSIGNED_INT_RAW12_EXT 0x10E4 + +/*************************************************************** +* cl_khr_3d_image_writes +***************************************************************/ +#define cl_khr_3d_image_writes 1 +#define CL_KHR_3D_IMAGE_WRITES_EXTENSION_NAME \ + "cl_khr_3d_image_writes" + + +#define CL_KHR_3D_IMAGE_WRITES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_async_work_group_copy_fence +***************************************************************/ +#define cl_khr_async_work_group_copy_fence 1 +#define CL_KHR_ASYNC_WORK_GROUP_COPY_FENCE_EXTENSION_NAME \ + "cl_khr_async_work_group_copy_fence" + + +#define CL_KHR_ASYNC_WORK_GROUP_COPY_FENCE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_byte_addressable_store +***************************************************************/ +#define cl_khr_byte_addressable_store 1 +#define CL_KHR_BYTE_ADDRESSABLE_STORE_EXTENSION_NAME \ + "cl_khr_byte_addressable_store" + + +#define CL_KHR_BYTE_ADDRESSABLE_STORE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_device_enqueue_local_arg_types +***************************************************************/ +#define cl_khr_device_enqueue_local_arg_types 1 +#define CL_KHR_DEVICE_ENQUEUE_LOCAL_ARG_TYPES_EXTENSION_NAME \ + "cl_khr_device_enqueue_local_arg_types" + + +#define CL_KHR_DEVICE_ENQUEUE_LOCAL_ARG_TYPES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_expect_assume +***************************************************************/ +#define cl_khr_expect_assume 1 +#define CL_KHR_EXPECT_ASSUME_EXTENSION_NAME \ + "cl_khr_expect_assume" + + +#define CL_KHR_EXPECT_ASSUME_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_extended_async_copies +***************************************************************/ +#define cl_khr_extended_async_copies 1 +#define CL_KHR_EXTENDED_ASYNC_COPIES_EXTENSION_NAME \ + "cl_khr_extended_async_copies" + + +#define CL_KHR_EXTENDED_ASYNC_COPIES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_extended_bit_ops +***************************************************************/ +#define cl_khr_extended_bit_ops 1 +#define CL_KHR_EXTENDED_BIT_OPS_EXTENSION_NAME \ + "cl_khr_extended_bit_ops" + + +#define CL_KHR_EXTENDED_BIT_OPS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_global_int32_base_atomics +***************************************************************/ +#define cl_khr_global_int32_base_atomics 1 +#define CL_KHR_GLOBAL_INT32_BASE_ATOMICS_EXTENSION_NAME \ + "cl_khr_global_int32_base_atomics" + + +#define CL_KHR_GLOBAL_INT32_BASE_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_global_int32_extended_atomics +***************************************************************/ +#define cl_khr_global_int32_extended_atomics 1 +#define CL_KHR_GLOBAL_INT32_EXTENDED_ATOMICS_EXTENSION_NAME \ + "cl_khr_global_int32_extended_atomics" + + +#define CL_KHR_GLOBAL_INT32_EXTENDED_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/*************************************************************** +* cl_khr_int64_base_atomics +***************************************************************/ +#define cl_khr_int64_base_atomics 1 +#define CL_KHR_INT64_BASE_ATOMICS_EXTENSION_NAME \ + "cl_khr_int64_base_atomics" + + +#define CL_KHR_INT64_BASE_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef cl_int (CL_API_CALL * -clMemBlockingFreeINTEL_fn)( - cl_context context, - void* ptr) ; +/*************************************************************** +* cl_khr_int64_extended_atomics +***************************************************************/ +#define cl_khr_int64_extended_atomics 1 +#define CL_KHR_INT64_EXTENDED_ATOMICS_EXTENSION_NAME \ + "cl_khr_int64_extended_atomics" -typedef cl_int (CL_API_CALL * -clGetMemAllocInfoINTEL_fn)( - cl_context context, - const void* ptr, - cl_mem_info_intel param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) ; -typedef cl_int (CL_API_CALL * -clSetKernelArgMemPointerINTEL_fn)( - cl_kernel kernel, - cl_uint arg_index, - const void* arg_value) ; +#define CL_KHR_INT64_EXTENDED_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef cl_int (CL_API_CALL * -clEnqueueMemFillINTEL_fn)( - cl_command_queue command_queue, - void* dst_ptr, - const void* pattern, - size_t pattern_size, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +/*************************************************************** +* cl_khr_kernel_clock +***************************************************************/ +#define cl_khr_kernel_clock 1 +#define CL_KHR_KERNEL_CLOCK_EXTENSION_NAME \ + "cl_khr_kernel_clock" -typedef cl_int (CL_API_CALL * -clEnqueueMemcpyINTEL_fn)( - cl_command_queue command_queue, - cl_bool blocking, - void* dst_ptr, - const void* src_ptr, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; -typedef cl_int (CL_API_CALL * -clEnqueueMemAdviseINTEL_fn)( - cl_command_queue command_queue, - const void* ptr, - size_t size, - cl_mem_advice_intel advice, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +#define CL_KHR_KERNEL_CLOCK_EXTENSION_VERSION CL_MAKE_VERSION(0, 9, 0) -#ifndef CL_NO_PROTOTYPES +/* cl_device_info */ +#define CL_DEVICE_KERNEL_CLOCK_CAPABILITIES_KHR 0x1076 -extern CL_API_ENTRY void* CL_API_CALL -clHostMemAllocINTEL( - cl_context context, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; +typedef cl_bitfield cl_device_kernel_clock_capabilities_khr; -extern CL_API_ENTRY void* CL_API_CALL -clDeviceMemAllocINTEL( - cl_context context, - cl_device_id device, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; +/* cl_device_kernel_clock_capabilities_khr */ +#define CL_DEVICE_KERNEL_CLOCK_SCOPE_DEVICE_KHR (1 << 0) +#define CL_DEVICE_KERNEL_CLOCK_SCOPE_WORK_GROUP_KHR (1 << 1) +#define CL_DEVICE_KERNEL_CLOCK_SCOPE_SUB_GROUP_KHR (1 << 2) -extern CL_API_ENTRY void* CL_API_CALL -clSharedMemAllocINTEL( - cl_context context, - cl_device_id device, - const cl_mem_properties_intel* properties, - size_t size, - cl_uint alignment, - cl_int* errcode_ret) ; +/*************************************************************** +* cl_khr_local_int32_base_atomics +***************************************************************/ +#define cl_khr_local_int32_base_atomics 1 +#define CL_KHR_LOCAL_INT32_BASE_ATOMICS_EXTENSION_NAME \ + "cl_khr_local_int32_base_atomics" -extern CL_API_ENTRY cl_int CL_API_CALL -clMemFreeINTEL( - cl_context context, - void* ptr) ; -extern CL_API_ENTRY cl_int CL_API_CALL -clMemBlockingFreeINTEL( - cl_context context, - void* ptr) ; +#define CL_KHR_LOCAL_INT32_BASE_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY cl_int CL_API_CALL -clGetMemAllocInfoINTEL( - cl_context context, - const void* ptr, - cl_mem_info_intel param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) ; +/*************************************************************** +* cl_khr_local_int32_extended_atomics +***************************************************************/ +#define cl_khr_local_int32_extended_atomics 1 +#define CL_KHR_LOCAL_INT32_EXTENDED_ATOMICS_EXTENSION_NAME \ + "cl_khr_local_int32_extended_atomics" -extern CL_API_ENTRY cl_int CL_API_CALL -clSetKernelArgMemPointerINTEL( - cl_kernel kernel, - cl_uint arg_index, - const void* arg_value) ; -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMemFillINTEL( - cl_command_queue command_queue, - void* dst_ptr, - const void* pattern, - size_t pattern_size, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +#define CL_KHR_LOCAL_INT32_EXTENDED_ATOMICS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMemcpyINTEL( - cl_command_queue command_queue, - cl_bool blocking, - void* dst_ptr, - const void* src_ptr, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +/*************************************************************** +* cl_khr_mipmap_image_writes +***************************************************************/ +#define cl_khr_mipmap_image_writes 1 +#define CL_KHR_MIPMAP_IMAGE_WRITES_EXTENSION_NAME \ + "cl_khr_mipmap_image_writes" -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMemAdviseINTEL( - cl_command_queue command_queue, - const void* ptr, - size_t size, - cl_mem_advice_intel advice, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; -#endif /* CL_NO_PROTOTYPES */ +#define CL_KHR_MIPMAP_IMAGE_WRITES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -#if defined(CL_VERSION_1_2) -/* Requires OpenCL 1.2 for cl_mem_migration_flags: */ +/*************************************************************** +* cl_khr_select_fprounding_mode +***************************************************************/ +#define cl_khr_select_fprounding_mode 1 +#define CL_KHR_SELECT_FPROUNDING_MODE_EXTENSION_NAME \ + "cl_khr_select_fprounding_mode" -typedef cl_int (CL_API_CALL * -clEnqueueMigrateMemINTEL_fn)( - cl_command_queue command_queue, - const void* ptr, - size_t size, - cl_mem_migration_flags flags, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; -#ifndef CL_NO_PROTOTYPES +#define CL_KHR_SELECT_FPROUNDING_MODE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMigrateMemINTEL( - cl_command_queue command_queue, - const void* ptr, - size_t size, - cl_mem_migration_flags flags, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +/*************************************************************** +* cl_khr_spirv_extended_debug_info +***************************************************************/ +#define cl_khr_spirv_extended_debug_info 1 +#define CL_KHR_SPIRV_EXTENDED_DEBUG_INFO_EXTENSION_NAME \ + "cl_khr_spirv_extended_debug_info" -#endif /* CL_NO_PROTOTYPES */ -#endif /* defined(CL_VERSION_1_2) */ +#define CL_KHR_SPIRV_EXTENDED_DEBUG_INFO_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* deprecated, use clEnqueueMemFillINTEL instead */ +/*************************************************************** +* cl_khr_spirv_linkonce_odr +***************************************************************/ +#define cl_khr_spirv_linkonce_odr 1 +#define CL_KHR_SPIRV_LINKONCE_ODR_EXTENSION_NAME \ + "cl_khr_spirv_linkonce_odr" -typedef cl_int (CL_API_CALL * -clEnqueueMemsetINTEL_fn)( - cl_command_queue command_queue, - void* dst_ptr, - cl_int value, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; -#ifndef CL_NO_PROTOTYPES +#define CL_KHR_SPIRV_LINKONCE_ODR_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMemsetINTEL( - cl_command_queue command_queue, - void* dst_ptr, - cl_int value, - size_t size, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) ; +/*************************************************************** +* cl_khr_spirv_no_integer_wrap_decoration +***************************************************************/ +#define cl_khr_spirv_no_integer_wrap_decoration 1 +#define CL_KHR_SPIRV_NO_INTEGER_WRAP_DECORATION_EXTENSION_NAME \ + "cl_khr_spirv_no_integer_wrap_decoration" -#endif /* CL_NO_PROTOTYPES */ + +#define CL_KHR_SPIRV_NO_INTEGER_WRAP_DECORATION_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /*************************************************************** -* cl_intel_mem_alloc_buffer_location +* cl_khr_srgb_image_writes ***************************************************************/ -#define cl_intel_mem_alloc_buffer_location 1 -#define CL_INTEL_MEM_ALLOC_BUFFER_LOCATION_EXTENSION_NAME \ - "cl_intel_mem_alloc_buffer_location" +#define cl_khr_srgb_image_writes 1 +#define CL_KHR_SRGB_IMAGE_WRITES_EXTENSION_NAME \ + "cl_khr_srgb_image_writes" -/* cl_mem_properties_intel */ -#define CL_MEM_ALLOC_BUFFER_LOCATION_INTEL 0x419E -/* cl_mem_alloc_info_intel */ -/* enum CL_MEM_ALLOC_BUFFER_LOCATION_INTEL */ +#define CL_KHR_SRGB_IMAGE_WRITES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/*************************************************** -* cl_intel_create_buffer_with_properties extension * -****************************************************/ +/*************************************************************** +* cl_khr_subgroup_ballot +***************************************************************/ +#define cl_khr_subgroup_ballot 1 +#define CL_KHR_SUBGROUP_BALLOT_EXTENSION_NAME \ + "cl_khr_subgroup_ballot" -#define cl_intel_create_buffer_with_properties 1 -extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateBufferWithPropertiesINTEL( - cl_context context, - const cl_mem_properties_intel* properties, - cl_mem_flags flags, - size_t size, - void * host_ptr, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; +#define CL_KHR_SUBGROUP_BALLOT_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef cl_mem (CL_API_CALL * -clCreateBufferWithPropertiesINTEL_fn)( - cl_context context, - const cl_mem_properties_intel* properties, - cl_mem_flags flags, - size_t size, - void * host_ptr, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; +/*************************************************************** +* cl_khr_subgroup_clustered_reduce +***************************************************************/ +#define cl_khr_subgroup_clustered_reduce 1 +#define CL_KHR_SUBGROUP_CLUSTERED_REDUCE_EXTENSION_NAME \ + "cl_khr_subgroup_clustered_reduce" -/****************************************** -* cl_intel_mem_channel_property extension * -*******************************************/ -#define CL_MEM_CHANNEL_INTEL 0x4213 +#define CL_KHR_SUBGROUP_CLUSTERED_REDUCE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/********************************* -* cl_intel_mem_force_host_memory * -**********************************/ +/*************************************************************** +* cl_khr_subgroup_extended_types +***************************************************************/ +#define cl_khr_subgroup_extended_types 1 +#define CL_KHR_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME \ + "cl_khr_subgroup_extended_types" -#define cl_intel_mem_force_host_memory 1 -/* cl_mem_flags */ -#define CL_MEM_FORCE_HOST_MEMORY_INTEL (1 << 20) +#define CL_KHR_SUBGROUP_EXTENDED_TYPES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /*************************************************************** -* cl_intel_command_queue_families +* cl_khr_subgroup_non_uniform_arithmetic ***************************************************************/ -#define cl_intel_command_queue_families 1 +#define cl_khr_subgroup_non_uniform_arithmetic 1 +#define CL_KHR_SUBGROUP_NON_UNIFORM_ARITHMETIC_EXTENSION_NAME \ + "cl_khr_subgroup_non_uniform_arithmetic" -typedef cl_bitfield cl_command_queue_capabilities_intel; -#define CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL 64 +#define CL_KHR_SUBGROUP_NON_UNIFORM_ARITHMETIC_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef struct _cl_queue_family_properties_intel { - cl_command_queue_properties properties; - cl_command_queue_capabilities_intel capabilities; - cl_uint count; - char name[CL_QUEUE_FAMILY_MAX_NAME_SIZE_INTEL]; -} cl_queue_family_properties_intel; +/*************************************************************** +* cl_khr_subgroup_non_uniform_vote +***************************************************************/ +#define cl_khr_subgroup_non_uniform_vote 1 +#define CL_KHR_SUBGROUP_NON_UNIFORM_VOTE_EXTENSION_NAME \ + "cl_khr_subgroup_non_uniform_vote" -/* cl_device_info */ -#define CL_DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL 0x418B -/* cl_queue_properties */ -#define CL_QUEUE_FAMILY_INTEL 0x418C -#define CL_QUEUE_INDEX_INTEL 0x418D +#define CL_KHR_SUBGROUP_NON_UNIFORM_VOTE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -/* cl_command_queue_capabilities_intel */ -#define CL_QUEUE_DEFAULT_CAPABILITIES_INTEL 0 -#define CL_QUEUE_CAPABILITY_CREATE_SINGLE_QUEUE_EVENTS_INTEL (1 << 0) -#define CL_QUEUE_CAPABILITY_CREATE_CROSS_QUEUE_EVENTS_INTEL (1 << 1) -#define CL_QUEUE_CAPABILITY_SINGLE_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 2) -#define CL_QUEUE_CAPABILITY_CROSS_QUEUE_EVENT_WAIT_LIST_INTEL (1 << 3) -#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_INTEL (1 << 8) -#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_RECT_INTEL (1 << 9) -#define CL_QUEUE_CAPABILITY_MAP_BUFFER_INTEL (1 << 10) -#define CL_QUEUE_CAPABILITY_FILL_BUFFER_INTEL (1 << 11) -#define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_INTEL (1 << 12) -#define CL_QUEUE_CAPABILITY_MAP_IMAGE_INTEL (1 << 13) -#define CL_QUEUE_CAPABILITY_FILL_IMAGE_INTEL (1 << 14) -#define CL_QUEUE_CAPABILITY_TRANSFER_BUFFER_IMAGE_INTEL (1 << 15) -#define CL_QUEUE_CAPABILITY_TRANSFER_IMAGE_BUFFER_INTEL (1 << 16) -#define CL_QUEUE_CAPABILITY_MARKER_INTEL (1 << 24) -#define CL_QUEUE_CAPABILITY_BARRIER_INTEL (1 << 25) -#define CL_QUEUE_CAPABILITY_KERNEL_INTEL (1 << 26) +/*************************************************************** +* cl_khr_subgroup_rotate +***************************************************************/ +#define cl_khr_subgroup_rotate 1 +#define CL_KHR_SUBGROUP_ROTATE_EXTENSION_NAME \ + "cl_khr_subgroup_rotate" + + +#define CL_KHR_SUBGROUP_ROTATE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /*************************************************************** -* cl_intel_sharing_format_query +* cl_khr_subgroup_shuffle ***************************************************************/ -#define cl_intel_sharing_format_query 1 +#define cl_khr_subgroup_shuffle 1 +#define CL_KHR_SUBGROUP_SHUFFLE_EXTENSION_NAME \ + "cl_khr_subgroup_shuffle" + + +#define CL_KHR_SUBGROUP_SHUFFLE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) /*************************************************************** -* cl_ext_image_requirements_info +* cl_khr_subgroup_shuffle_relative ***************************************************************/ +#define cl_khr_subgroup_shuffle_relative 1 +#define CL_KHR_SUBGROUP_SHUFFLE_RELATIVE_EXTENSION_NAME \ + "cl_khr_subgroup_shuffle_relative" -#ifdef CL_VERSION_3_0 -#define cl_ext_image_requirements_info 1 +#define CL_KHR_SUBGROUP_SHUFFLE_RELATIVE_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef cl_uint cl_image_requirements_info_ext; +/*************************************************************** +* cl_khr_work_group_uniform_arithmetic +***************************************************************/ +#define cl_khr_work_group_uniform_arithmetic 1 +#define CL_KHR_WORK_GROUP_UNIFORM_ARITHMETIC_EXTENSION_NAME \ + "cl_khr_work_group_uniform_arithmetic" -#define CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT 0x1290 -#define CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT 0x1292 -#define CL_IMAGE_REQUIREMENTS_SIZE_EXT 0x12B2 -#define CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT 0x12B3 -#define CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT 0x12B4 -#define CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT 0x12B5 -#define CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT 0x12B6 -extern CL_API_ENTRY cl_int CL_API_CALL -clGetImageRequirementsInfoEXT( - cl_context context, - const cl_mem_properties* properties, - cl_mem_flags flags, - const cl_image_format* image_format, - const cl_image_desc* image_desc, - cl_image_requirements_info_ext param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_3_0; +#define CL_KHR_WORK_GROUP_UNIFORM_ARITHMETIC_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) -typedef cl_int (CL_API_CALL * -clGetImageRequirementsInfoEXT_fn)( - cl_context context, - const cl_mem_properties* properties, - cl_mem_flags flags, - const cl_image_format* image_format, - const cl_image_desc* image_desc, - cl_image_requirements_info_ext param_name, - size_t param_value_size, - void* param_value, - size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_3_0; +/*************************************************************** +* cl_ext_image_unorm_int_2_101010 +***************************************************************/ +#define cl_ext_image_unorm_int_2_101010 1 +#define CL_EXT_IMAGE_UNORM_INT_2_101010_EXTENSION_NAME \ + "cl_ext_image_unorm_int_2_101010" -#endif + +#define CL_EXT_IMAGE_UNORM_INT_2_101010_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* cl_channel_type */ +#define CL_UNORM_INT_2_101010_EXT 0x10E5 /*************************************************************** -* cl_ext_image_from_buffer +* cl_img_cancel_command ***************************************************************/ +#define cl_img_cancel_command 1 +#define CL_IMG_CANCEL_COMMAND_EXTENSION_NAME \ + "cl_img_cancel_command" -#ifdef CL_VERSION_3_0 -#define cl_ext_image_from_buffer 1 +#define CL_IMG_CANCEL_COMMAND_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) + +/* Error codes */ +#define CL_CANCELLED_IMG -1126 -#define CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT 0x1291 -#endif +typedef cl_int CL_API_CALL +clCancelCommandsIMG_t( + const cl_event* event_list, + size_t num_events_in_list); + +typedef clCancelCommandsIMG_t * +clCancelCommandsIMG_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clCancelCommandsIMG( + const cl_event* event_list, + size_t num_events_in_list) ; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif - -#endif /* __CL_EXT_H */ +#endif /* OPENCL_CL_EXT_H_ */ diff --git a/deps/opencl-headers/CL/cl_function_types.h b/deps/opencl-headers/CL/cl_function_types.h new file mode 100644 index 000000000..124f53ba7 --- /dev/null +++ b/deps/opencl-headers/CL/cl_function_types.h @@ -0,0 +1,1184 @@ +/* + * 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. + * + * OpenCL is a trademark of Apple Inc. used under license by Khronos. + */ + +#ifndef OPENCL_CL_FUNCTION_TYPES_H_ +#define OPENCL_CL_FUNCTION_TYPES_H_ + +#include + +typedef cl_int CL_API_CALL clGetPlatformIDs_t( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms); + +typedef clGetPlatformIDs_t * +clGetPlatformIDs_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetPlatformInfo_t( + cl_platform_id platform, + cl_platform_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetPlatformInfo_t * +clGetPlatformInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetDeviceIDs_t( + cl_platform_id platform, + cl_device_type device_type, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDs_t * +clGetDeviceIDs_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetDeviceInfo_t( + cl_device_id device, + cl_device_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetDeviceInfo_t * +clGetDeviceInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_context CL_API_CALL clCreateContext_t( + const cl_context_properties* properties, + cl_uint num_devices, + const cl_device_id* devices, + void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), + void* user_data, + cl_int* errcode_ret); + +typedef clCreateContext_t * +clCreateContext_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_context CL_API_CALL clCreateContextFromType_t( + const cl_context_properties* properties, + cl_device_type device_type, + void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), + void* user_data, + cl_int* errcode_ret); + +typedef clCreateContextFromType_t * +clCreateContextFromType_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainContext_t( + cl_context context); + +typedef clRetainContext_t * +clRetainContext_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseContext_t( + cl_context context); + +typedef clReleaseContext_t * +clReleaseContext_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetContextInfo_t( + cl_context context, + cl_context_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetContextInfo_t * +clGetContextInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainCommandQueue_t( + cl_command_queue command_queue); + +typedef clRetainCommandQueue_t * +clRetainCommandQueue_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseCommandQueue_t( + cl_command_queue command_queue); + +typedef clReleaseCommandQueue_t * +clReleaseCommandQueue_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetCommandQueueInfo_t( + cl_command_queue command_queue, + cl_command_queue_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetCommandQueueInfo_t * +clGetCommandQueueInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_mem CL_API_CALL clCreateBuffer_t( + cl_context context, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateBuffer_t * +clCreateBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainMemObject_t( + cl_mem memobj); + +typedef clRetainMemObject_t * +clRetainMemObject_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseMemObject_t( + cl_mem memobj); + +typedef clReleaseMemObject_t * +clReleaseMemObject_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetSupportedImageFormats_t( + cl_context context, + cl_mem_flags flags, + cl_mem_object_type image_type, + cl_uint num_entries, + cl_image_format* image_formats, + cl_uint* num_image_formats); + +typedef clGetSupportedImageFormats_t * +clGetSupportedImageFormats_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetMemObjectInfo_t( + cl_mem memobj, + cl_mem_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetMemObjectInfo_t * +clGetMemObjectInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetImageInfo_t( + cl_mem image, + cl_image_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetImageInfo_t * +clGetImageInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainSampler_t( + cl_sampler sampler); + +typedef clRetainSampler_t * +clRetainSampler_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseSampler_t( + cl_sampler sampler); + +typedef clReleaseSampler_t * +clReleaseSampler_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetSamplerInfo_t( + cl_sampler sampler, + cl_sampler_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetSamplerInfo_t * +clGetSamplerInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_program CL_API_CALL clCreateProgramWithSource_t( + cl_context context, + cl_uint count, + const char** strings, + const size_t* lengths, + cl_int* errcode_ret); + +typedef clCreateProgramWithSource_t * +clCreateProgramWithSource_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_program CL_API_CALL clCreateProgramWithBinary_t( + cl_context context, + cl_uint num_devices, + const cl_device_id* device_list, + const size_t* lengths, + const unsigned char** binaries, + cl_int* binary_status, + cl_int* errcode_ret); + +typedef clCreateProgramWithBinary_t * +clCreateProgramWithBinary_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainProgram_t( + cl_program program); + +typedef clRetainProgram_t * +clRetainProgram_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseProgram_t( + cl_program program); + +typedef clReleaseProgram_t * +clReleaseProgram_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clBuildProgram_t( + cl_program program, + cl_uint num_devices, + const cl_device_id* device_list, + const char* options, + void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), + void* user_data); + +typedef clBuildProgram_t * +clBuildProgram_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetProgramInfo_t( + cl_program program, + cl_program_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetProgramInfo_t * +clGetProgramInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetProgramBuildInfo_t( + cl_program program, + cl_device_id device, + cl_program_build_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetProgramBuildInfo_t * +clGetProgramBuildInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_kernel CL_API_CALL clCreateKernel_t( + cl_program program, + const char* kernel_name, + cl_int* errcode_ret); + +typedef clCreateKernel_t * +clCreateKernel_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clCreateKernelsInProgram_t( + cl_program program, + cl_uint num_kernels, + cl_kernel* kernels, + cl_uint* num_kernels_ret); + +typedef clCreateKernelsInProgram_t * +clCreateKernelsInProgram_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainKernel_t( + cl_kernel kernel); + +typedef clRetainKernel_t * +clRetainKernel_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseKernel_t( + cl_kernel kernel); + +typedef clReleaseKernel_t * +clReleaseKernel_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clSetKernelArg_t( + cl_kernel kernel, + cl_uint arg_index, + size_t arg_size, + const void* arg_value); + +typedef clSetKernelArg_t * +clSetKernelArg_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetKernelInfo_t( + cl_kernel kernel, + cl_kernel_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetKernelInfo_t * +clGetKernelInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetKernelWorkGroupInfo_t( + cl_kernel kernel, + cl_device_id device, + cl_kernel_work_group_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetKernelWorkGroupInfo_t * +clGetKernelWorkGroupInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clWaitForEvents_t( + cl_uint num_events, + const cl_event* event_list); + +typedef clWaitForEvents_t * +clWaitForEvents_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetEventInfo_t( + cl_event event, + cl_event_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetEventInfo_t * +clGetEventInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clRetainEvent_t( + cl_event event); + +typedef clRetainEvent_t * +clRetainEvent_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clReleaseEvent_t( + cl_event event); + +typedef clReleaseEvent_t * +clReleaseEvent_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clGetEventProfilingInfo_t( + cl_event event, + cl_profiling_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetEventProfilingInfo_t * +clGetEventProfilingInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clFlush_t( + cl_command_queue command_queue); + +typedef clFlush_t * +clFlush_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clFinish_t( + cl_command_queue command_queue); + +typedef clFinish_t * +clFinish_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueReadBuffer_t( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_read, + size_t offset, + size_t size, + void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReadBuffer_t * +clEnqueueReadBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueWriteBuffer_t( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_write, + size_t offset, + size_t size, + const void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueWriteBuffer_t * +clEnqueueWriteBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueCopyBuffer_t( + cl_command_queue command_queue, + cl_mem src_buffer, + cl_mem dst_buffer, + size_t src_offset, + size_t dst_offset, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueCopyBuffer_t * +clEnqueueCopyBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueReadImage_t( + cl_command_queue command_queue, + cl_mem image, + cl_bool blocking_read, + const size_t* origin, + const size_t* region, + size_t row_pitch, + size_t slice_pitch, + void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReadImage_t * +clEnqueueReadImage_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueWriteImage_t( + cl_command_queue command_queue, + cl_mem image, + cl_bool blocking_write, + const size_t* origin, + const size_t* region, + size_t input_row_pitch, + size_t input_slice_pitch, + const void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueWriteImage_t * +clEnqueueWriteImage_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueCopyImage_t( + cl_command_queue command_queue, + cl_mem src_image, + cl_mem dst_image, + const size_t* src_origin, + const size_t* dst_origin, + const size_t* region, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueCopyImage_t * +clEnqueueCopyImage_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueCopyImageToBuffer_t( + cl_command_queue command_queue, + cl_mem src_image, + cl_mem dst_buffer, + const size_t* src_origin, + const size_t* region, + size_t dst_offset, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueCopyImageToBuffer_t * +clEnqueueCopyImageToBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueCopyBufferToImage_t( + cl_command_queue command_queue, + cl_mem src_buffer, + cl_mem dst_image, + size_t src_offset, + const size_t* dst_origin, + const size_t* region, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueCopyBufferToImage_t * +clEnqueueCopyBufferToImage_fn CL_API_SUFFIX__VERSION_1_0; + +typedef void* CL_API_CALL clEnqueueMapBuffer_t( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_map, + cl_map_flags map_flags, + size_t offset, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, + cl_int* errcode_ret); + +typedef clEnqueueMapBuffer_t * +clEnqueueMapBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef void* CL_API_CALL clEnqueueMapImage_t( + cl_command_queue command_queue, + cl_mem image, + cl_bool blocking_map, + cl_map_flags map_flags, + const size_t* origin, + const size_t* region, + size_t* image_row_pitch, + size_t* image_slice_pitch, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, + cl_int* errcode_ret); + +typedef clEnqueueMapImage_t * +clEnqueueMapImage_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueUnmapMemObject_t( + cl_command_queue command_queue, + cl_mem memobj, + void* mapped_ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueUnmapMemObject_t * +clEnqueueUnmapMemObject_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueNDRangeKernel_t( + cl_command_queue command_queue, + cl_kernel kernel, + cl_uint work_dim, + const size_t* global_work_offset, + const size_t* global_work_size, + const size_t* local_work_size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueNDRangeKernel_t * +clEnqueueNDRangeKernel_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clEnqueueNativeKernel_t( + cl_command_queue command_queue, + void (CL_CALLBACK* user_func)(void*), + void* args, + size_t cb_args, + cl_uint num_mem_objects, + const cl_mem* mem_list, + const void** args_mem_loc, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueNativeKernel_t * +clEnqueueNativeKernel_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL clSetCommandQueueProperty_t( + cl_command_queue command_queue, + cl_command_queue_properties properties, + cl_bool enable, + cl_command_queue_properties* old_properties); + +typedef clSetCommandQueueProperty_t * +clSetCommandQueueProperty_fn CL_API_SUFFIX__VERSION_1_0_DEPRECATED; + +typedef cl_mem CL_API_CALL clCreateImage2D_t( + cl_context context, + cl_mem_flags flags, + const cl_image_format* image_format, + size_t image_width, + size_t image_height, + size_t image_row_pitch, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateImage2D_t * +clCreateImage2D_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_mem CL_API_CALL clCreateImage3D_t( + cl_context context, + cl_mem_flags flags, + const cl_image_format* image_format, + size_t image_width, + size_t image_height, + size_t image_depth, + size_t image_row_pitch, + size_t image_slice_pitch, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateImage3D_t * +clCreateImage3D_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_int CL_API_CALL clEnqueueMarker_t( + cl_command_queue command_queue, + cl_event* event); + +typedef clEnqueueMarker_t * +clEnqueueMarker_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_int CL_API_CALL clEnqueueWaitForEvents_t( + cl_command_queue command_queue, + cl_uint num_events, + const cl_event* event_list); + +typedef clEnqueueWaitForEvents_t * +clEnqueueWaitForEvents_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_int CL_API_CALL clEnqueueBarrier_t( + cl_command_queue command_queue); + +typedef clEnqueueBarrier_t * +clEnqueueBarrier_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_int CL_API_CALL clUnloadCompiler_t( + void ); + +typedef clUnloadCompiler_t * +clUnloadCompiler_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef void* CL_API_CALL clGetExtensionFunctionAddress_t( + const char* func_name); + +typedef clGetExtensionFunctionAddress_t * +clGetExtensionFunctionAddress_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +typedef cl_command_queue CL_API_CALL clCreateCommandQueue_t( + cl_context context, + cl_device_id device, + cl_command_queue_properties properties, + cl_int* errcode_ret); + +typedef clCreateCommandQueue_t * +clCreateCommandQueue_fn CL_API_SUFFIX__VERSION_1_2_DEPRECATED; + +typedef cl_sampler CL_API_CALL clCreateSampler_t( + cl_context context, + cl_bool normalized_coords, + cl_addressing_mode addressing_mode, + cl_filter_mode filter_mode, + cl_int* errcode_ret); + +typedef clCreateSampler_t * +clCreateSampler_fn CL_API_SUFFIX__VERSION_1_2_DEPRECATED; + +typedef cl_int CL_API_CALL clEnqueueTask_t( + cl_command_queue command_queue, + cl_kernel kernel, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueTask_t * +clEnqueueTask_fn CL_API_SUFFIX__VERSION_1_2_DEPRECATED; + +#ifdef CL_VERSION_1_1 + +typedef cl_mem CL_API_CALL clCreateSubBuffer_t( + cl_mem buffer, + cl_mem_flags flags, + cl_buffer_create_type buffer_create_type, + const void* buffer_create_info, + cl_int* errcode_ret); + +typedef clCreateSubBuffer_t * +clCreateSubBuffer_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clSetMemObjectDestructorCallback_t( + cl_mem memobj, + void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), + void* user_data); + +typedef clSetMemObjectDestructorCallback_t * +clSetMemObjectDestructorCallback_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_event CL_API_CALL clCreateUserEvent_t( + cl_context context, + cl_int* errcode_ret); + +typedef clCreateUserEvent_t * +clCreateUserEvent_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clSetUserEventStatus_t( + cl_event event, + cl_int execution_status); + +typedef clSetUserEventStatus_t * +clSetUserEventStatus_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clSetEventCallback_t( + cl_event event, + cl_int command_exec_callback_type, + void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), + void* user_data); + +typedef clSetEventCallback_t * +clSetEventCallback_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clEnqueueReadBufferRect_t( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_read, + const size_t* buffer_origin, + const size_t* host_origin, + const size_t* region, + size_t buffer_row_pitch, + size_t buffer_slice_pitch, + size_t host_row_pitch, + size_t host_slice_pitch, + void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReadBufferRect_t * +clEnqueueReadBufferRect_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clEnqueueWriteBufferRect_t( + cl_command_queue command_queue, + cl_mem buffer, + cl_bool blocking_write, + const size_t* buffer_origin, + const size_t* host_origin, + const size_t* region, + size_t buffer_row_pitch, + size_t buffer_slice_pitch, + size_t host_row_pitch, + size_t host_slice_pitch, + const void* ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueWriteBufferRect_t * +clEnqueueWriteBufferRect_fn CL_API_SUFFIX__VERSION_1_1; + +typedef cl_int CL_API_CALL clEnqueueCopyBufferRect_t( + cl_command_queue command_queue, + cl_mem src_buffer, + cl_mem dst_buffer, + const size_t* src_origin, + const size_t* dst_origin, + const size_t* region, + size_t src_row_pitch, + size_t src_slice_pitch, + size_t dst_row_pitch, + size_t dst_slice_pitch, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueCopyBufferRect_t * +clEnqueueCopyBufferRect_fn CL_API_SUFFIX__VERSION_1_1; + +#endif /* CL_VERSION_1_1 */ + +#ifdef CL_VERSION_1_2 + +typedef cl_int CL_API_CALL clCreateSubDevices_t( + cl_device_id in_device, + const cl_device_partition_property* properties, + cl_uint num_devices, + cl_device_id* out_devices, + cl_uint* num_devices_ret); + +typedef clCreateSubDevices_t * +clCreateSubDevices_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clRetainDevice_t( + cl_device_id device); + +typedef clRetainDevice_t * +clRetainDevice_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clReleaseDevice_t( + cl_device_id device); + +typedef clReleaseDevice_t * +clReleaseDevice_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL clCreateImage_t( + cl_context context, + cl_mem_flags flags, + const cl_image_format* image_format, + const cl_image_desc* image_desc, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateImage_t * +clCreateImage_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_t( + cl_context context, + cl_uint num_devices, + const cl_device_id* device_list, + const char* kernel_names, + cl_int* errcode_ret); + +typedef clCreateProgramWithBuiltInKernels_t * +clCreateProgramWithBuiltInKernels_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clCompileProgram_t( + cl_program program, + cl_uint num_devices, + const cl_device_id* device_list, + const char* options, + cl_uint num_input_headers, + const cl_program* input_headers, + const char** header_include_names, + void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), + void* user_data); + +typedef clCompileProgram_t * +clCompileProgram_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_program CL_API_CALL clLinkProgram_t( + cl_context context, + cl_uint num_devices, + const cl_device_id* device_list, + const char* options, + cl_uint num_input_programs, + const cl_program* input_programs, + void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), + void* user_data, + cl_int* errcode_ret); + +typedef clLinkProgram_t * +clLinkProgram_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clUnloadPlatformCompiler_t( + cl_platform_id platform); + +typedef clUnloadPlatformCompiler_t * +clUnloadPlatformCompiler_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clGetKernelArgInfo_t( + cl_kernel kernel, + cl_uint arg_index, + cl_kernel_arg_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetKernelArgInfo_t * +clGetKernelArgInfo_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clEnqueueFillBuffer_t( + cl_command_queue command_queue, + cl_mem buffer, + const void* pattern, + size_t pattern_size, + size_t offset, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueFillBuffer_t * +clEnqueueFillBuffer_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clEnqueueFillImage_t( + cl_command_queue command_queue, + cl_mem image, + const void* fill_color, + const size_t* origin, + const size_t* region, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueFillImage_t * +clEnqueueFillImage_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clEnqueueMigrateMemObjects_t( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_mem_migration_flags flags, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMigrateMemObjects_t * +clEnqueueMigrateMemObjects_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clEnqueueMarkerWithWaitList_t( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueMarkerWithWaitList_t * +clEnqueueMarkerWithWaitList_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL clEnqueueBarrierWithWaitList_t( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueBarrierWithWaitList_t * +clEnqueueBarrierWithWaitList_fn CL_API_SUFFIX__VERSION_1_2; + +typedef void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_t( + cl_platform_id platform, + const char* func_name); + +typedef clGetExtensionFunctionAddressForPlatform_t * +clGetExtensionFunctionAddressForPlatform_fn CL_API_SUFFIX__VERSION_1_2; + +#endif /* CL_VERSION_1_2 */ + +#ifdef CL_VERSION_2_0 + +typedef cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_t( + cl_context context, + cl_device_id device, + const cl_queue_properties* properties, + cl_int* errcode_ret); + +typedef clCreateCommandQueueWithProperties_t * +clCreateCommandQueueWithProperties_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_mem CL_API_CALL clCreatePipe_t( + cl_context context, + cl_mem_flags flags, + cl_uint pipe_packet_size, + cl_uint pipe_max_packets, + const cl_pipe_properties* properties, + cl_int* errcode_ret); + +typedef clCreatePipe_t * +clCreatePipe_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clGetPipeInfo_t( + cl_mem pipe, + cl_pipe_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetPipeInfo_t * +clGetPipeInfo_fn CL_API_SUFFIX__VERSION_2_0; + +typedef void* CL_API_CALL clSVMAlloc_t( + cl_context context, + cl_svm_mem_flags flags, + size_t size, + cl_uint alignment); + +typedef clSVMAlloc_t * +clSVMAlloc_fn CL_API_SUFFIX__VERSION_2_0; + +typedef void CL_API_CALL clSVMFree_t( + cl_context context, + void* svm_pointer); + +typedef clSVMFree_t * +clSVMFree_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_sampler CL_API_CALL clCreateSamplerWithProperties_t( + cl_context context, + const cl_sampler_properties* sampler_properties, + cl_int* errcode_ret); + +typedef clCreateSamplerWithProperties_t * +clCreateSamplerWithProperties_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clSetKernelArgSVMPointer_t( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value); + +typedef clSetKernelArgSVMPointer_t * +clSetKernelArgSVMPointer_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clSetKernelExecInfo_t( + cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void* param_value); + +typedef clSetKernelExecInfo_t * +clSetKernelExecInfo_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clEnqueueSVMFree_t( + cl_command_queue command_queue, + cl_uint num_svm_pointers, + void* svm_pointers[], + void (CL_CALLBACK* pfn_free_func)(cl_command_queue queue, cl_uint num_svm_pointers, void* svm_pointers[], void* user_data), + void* user_data, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMFree_t * +clEnqueueSVMFree_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clEnqueueSVMMemcpy_t( + cl_command_queue command_queue, + cl_bool blocking_copy, + void* dst_ptr, + const void* src_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMemcpy_t * +clEnqueueSVMMemcpy_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clEnqueueSVMMemFill_t( + cl_command_queue command_queue, + void* svm_ptr, + const void* pattern, + size_t pattern_size, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMemFill_t * +clEnqueueSVMMemFill_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clEnqueueSVMMap_t( + cl_command_queue command_queue, + cl_bool blocking_map, + cl_map_flags flags, + void* svm_ptr, + size_t size, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMap_t * +clEnqueueSVMMap_fn CL_API_SUFFIX__VERSION_2_0; + +typedef cl_int CL_API_CALL clEnqueueSVMUnmap_t( + cl_command_queue command_queue, + void* svm_ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMUnmap_t * +clEnqueueSVMUnmap_fn CL_API_SUFFIX__VERSION_2_0; + +#endif /* CL_VERSION_2_0 */ + +#ifdef CL_VERSION_2_1 + +typedef cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_t( + cl_context context, + cl_device_id device, + cl_command_queue command_queue); + +typedef clSetDefaultDeviceCommandQueue_t * +clSetDefaultDeviceCommandQueue_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_int CL_API_CALL clGetDeviceAndHostTimer_t( + cl_device_id device, + cl_ulong* device_timestamp, + cl_ulong* host_timestamp); + +typedef clGetDeviceAndHostTimer_t * +clGetDeviceAndHostTimer_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_int CL_API_CALL clGetHostTimer_t( + cl_device_id device, + cl_ulong* host_timestamp); + +typedef clGetHostTimer_t * +clGetHostTimer_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_program CL_API_CALL clCreateProgramWithIL_t( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret); + +typedef clCreateProgramWithIL_t * +clCreateProgramWithIL_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_kernel CL_API_CALL clCloneKernel_t( + cl_kernel source_kernel, + cl_int* errcode_ret); + +typedef clCloneKernel_t * +clCloneKernel_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_int CL_API_CALL clGetKernelSubGroupInfo_t( + cl_kernel kernel, + cl_device_id device, + cl_kernel_sub_group_info param_name, + size_t input_value_size, + const void* input_value, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetKernelSubGroupInfo_t * +clGetKernelSubGroupInfo_fn CL_API_SUFFIX__VERSION_2_1; + +typedef cl_int CL_API_CALL clEnqueueSVMMigrateMem_t( + cl_command_queue command_queue, + cl_uint num_svm_pointers, + const void** svm_pointers, + const size_t* sizes, + cl_mem_migration_flags flags, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueSVMMigrateMem_t * +clEnqueueSVMMigrateMem_fn CL_API_SUFFIX__VERSION_2_1; + +#endif /* CL_VERSION_2_1 */ + +#ifdef CL_VERSION_2_2 + +typedef cl_int CL_API_CALL clSetProgramSpecializationConstant_t( + cl_program program, + cl_uint spec_id, + size_t spec_size, + const void* spec_value); + +typedef clSetProgramSpecializationConstant_t * +clSetProgramSpecializationConstant_fn CL_API_SUFFIX__VERSION_2_2; + +typedef cl_int CL_API_CALL clSetProgramReleaseCallback_t( + cl_program program, + void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), + void* user_data); + +typedef clSetProgramReleaseCallback_t * +clSetProgramReleaseCallback_fn CL_API_SUFFIX__VERSION_2_2_DEPRECATED; + +#endif /* CL_VERSION_2_2 */ + +#ifdef CL_VERSION_3_0 + +typedef cl_int CL_API_CALL clSetContextDestructorCallback_t( + cl_context context, + void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), + void* user_data); + +typedef clSetContextDestructorCallback_t * +clSetContextDestructorCallback_fn CL_API_SUFFIX__VERSION_3_0; + +typedef cl_mem CL_API_CALL clCreateBufferWithProperties_t( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateBufferWithProperties_t * +clCreateBufferWithProperties_fn CL_API_SUFFIX__VERSION_3_0; + +typedef cl_mem CL_API_CALL clCreateImageWithProperties_t( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + const cl_image_format* image_format, + const cl_image_desc* image_desc, + void* host_ptr, + cl_int* errcode_ret); + +typedef clCreateImageWithProperties_t * +clCreateImageWithProperties_fn CL_API_SUFFIX__VERSION_3_0; + +#endif /* CL_VERSION_3_0 */ + +#endif /* OPENCL_CL_FUNCTION_TYPES_H_ */ diff --git a/deps/opencl-headers/CL/cl_gl.h b/deps/opencl-headers/CL/cl_gl.h index 327746508..552560f71 100644 --- a/deps/opencl-headers/CL/cl_gl.h +++ b/deps/opencl-headers/CL/cl_gl.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2021 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,172 +14,397 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_GL_H -#define __OPENCL_CL_GL_H +#ifndef OPENCL_CL_GL_H_ +#define OPENCL_CL_GL_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ #include -#ifdef __cplusplus -extern "C" { +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES #endif -typedef cl_uint cl_gl_object_type; -typedef cl_uint cl_gl_texture_info; -typedef cl_uint cl_gl_platform_info; -typedef struct __GLsync *cl_GLsync; - -/* cl_gl_object_type = 0x2000 - 0x200F enum values are currently taken */ -#define CL_GL_OBJECT_BUFFER 0x2000 -#define CL_GL_OBJECT_TEXTURE2D 0x2001 -#define CL_GL_OBJECT_TEXTURE3D 0x2002 -#define CL_GL_OBJECT_RENDERBUFFER 0x2003 -#ifdef CL_VERSION_1_2 -#define CL_GL_OBJECT_TEXTURE2D_ARRAY 0x200E -#define CL_GL_OBJECT_TEXTURE1D 0x200F -#define CL_GL_OBJECT_TEXTURE1D_ARRAY 0x2010 -#define CL_GL_OBJECT_TEXTURE_BUFFER 0x2011 +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES #endif -/* cl_gl_texture_info */ -#define CL_GL_TEXTURE_TARGET 0x2004 -#define CL_GL_MIPMAP_LEVEL 0x2005 -#ifdef CL_VERSION_1_2 -#define CL_GL_NUM_SAMPLES 0x2012 +#ifdef __cplusplus +extern "C" { #endif +/*************************************************************** +* cl_khr_gl_sharing +***************************************************************/ +#define cl_khr_gl_sharing 1 +#define CL_KHR_GL_SHARING_EXTENSION_NAME \ + "cl_khr_gl_sharing" + + +#define CL_KHR_GL_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef int cl_GLint; +typedef unsigned int cl_GLenum; +typedef unsigned int cl_GLuint; + +typedef cl_uint cl_gl_context_info; + +/* Error codes */ +#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000 + +/* cl_gl_context_info */ +#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006 +#define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007 + +/* Additional cl_context_properties */ +#define CL_GL_CONTEXT_KHR 0x2008 +#define CL_EGL_DISPLAY_KHR 0x2009 +#define CL_GLX_DISPLAY_KHR 0x200A +#define CL_WGL_HDC_KHR 0x200B +#define CL_CGL_SHAREGROUP_KHR 0x200C + +typedef cl_uint cl_gl_object_type; +typedef cl_uint cl_gl_texture_info; +typedef cl_uint cl_gl_platform_info; + +/* cl_gl_object_type */ +#define CL_GL_OBJECT_BUFFER 0x2000 +#define CL_GL_OBJECT_TEXTURE2D 0x2001 +#define CL_GL_OBJECT_TEXTURE3D 0x2002 +#define CL_GL_OBJECT_RENDERBUFFER 0x2003 + +#if defined(CL_VERSION_1_2) +/* cl_gl_object_type */ +#define CL_GL_OBJECT_TEXTURE2D_ARRAY 0x200E +#define CL_GL_OBJECT_TEXTURE1D 0x200F +#define CL_GL_OBJECT_TEXTURE1D_ARRAY 0x2010 +#define CL_GL_OBJECT_TEXTURE_BUFFER 0x2011 + +#endif /* defined(CL_VERSION_1_2) */ + +/* cl_gl_texture_info */ +#define CL_GL_TEXTURE_TARGET 0x2004 +#define CL_GL_MIPMAP_LEVEL 0x2005 + + +typedef cl_int CL_API_CALL +clGetGLContextInfoKHR_t( + const cl_context_properties* properties, + cl_gl_context_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetGLContextInfoKHR_t * +clGetGLContextInfoKHR_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_mem CL_API_CALL +clCreateFromGLBuffer_t( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + cl_int* errcode_ret); + +typedef clCreateFromGLBuffer_t * +clCreateFromGLBuffer_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetGLContextInfoKHR( + const cl_context_properties* properties, + cl_gl_context_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromGLBuffer(cl_context context, - cl_mem_flags flags, - cl_GLuint bufobj, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; +clCreateFromGLBuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +#if defined(CL_VERSION_1_2) + +typedef cl_mem CL_API_CALL +clCreateFromGLTexture_t( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret); + +typedef clCreateFromGLTexture_t * +clCreateFromGLTexture_fn CL_API_SUFFIX__VERSION_1_2; -#ifdef CL_VERSION_1_2 +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromGLTexture(cl_context context, - cl_mem_flags flags, - cl_GLenum target, - cl_GLint miplevel, - cl_GLuint texture, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; +clCreateFromGLTexture( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; -#endif +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +#endif /* defined(CL_VERSION_1_2) */ + + +typedef cl_mem CL_API_CALL +clCreateFromGLRenderbuffer_t( + cl_context context, + cl_mem_flags flags, + cl_GLuint renderbuffer, + cl_int* errcode_ret); + +typedef clCreateFromGLRenderbuffer_t * +clCreateFromGLRenderbuffer_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clGetGLObjectInfo_t( + cl_mem memobj, + cl_gl_object_type* gl_object_type, + cl_GLuint* gl_object_name); + +typedef clGetGLObjectInfo_t * +clGetGLObjectInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clGetGLTextureInfo_t( + cl_mem memobj, + cl_gl_texture_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetGLTextureInfo_t * +clGetGLTextureInfo_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueAcquireGLObjects_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueAcquireGLObjects_t * +clEnqueueAcquireGLObjects_fn CL_API_SUFFIX__VERSION_1_0; + +typedef cl_int CL_API_CALL +clEnqueueReleaseGLObjects_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseGLObjects_t * +clEnqueueReleaseGLObjects_fn CL_API_SUFFIX__VERSION_1_0; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromGLRenderbuffer(cl_context context, - cl_mem_flags flags, - cl_GLuint renderbuffer, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; +clCreateFromGLRenderbuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint renderbuffer, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL -clGetGLObjectInfo(cl_mem memobj, - cl_gl_object_type * gl_object_type, - cl_GLuint * gl_object_name) CL_API_SUFFIX__VERSION_1_0; +clGetGLObjectInfo( + cl_mem memobj, + cl_gl_object_type* gl_object_type, + cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL -clGetGLTextureInfo(cl_mem memobj, - cl_gl_texture_info param_name, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; +clGetGLTextureInfo( + cl_mem memobj, + cl_gl_texture_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueAcquireGLObjects(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; +clEnqueueAcquireGLObjects( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; extern CL_API_ENTRY cl_int CL_API_CALL -clEnqueueReleaseGLObjects(cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem * mem_objects, - cl_uint num_events_in_wait_list, - const cl_event * event_wait_list, - cl_event * event) CL_API_SUFFIX__VERSION_1_0; - - -/* Deprecated OpenCL 1.1 APIs */ -extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL -clCreateFromGLTexture2D(cl_context context, - cl_mem_flags flags, - cl_GLenum target, - cl_GLint miplevel, - cl_GLuint texture, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -extern CL_API_ENTRY CL_API_PREFIX__VERSION_1_1_DEPRECATED cl_mem CL_API_CALL -clCreateFromGLTexture3D(cl_context context, - cl_mem_flags flags, - cl_GLenum target, - cl_GLint miplevel, - cl_GLuint texture, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -/* cl_khr_gl_sharing extension */ +clEnqueueReleaseGLObjects( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_0; -#define cl_khr_gl_sharing 1 +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/* OpenCL 1.0 APIs that were deprecated in OpenCL 1.2 */ -typedef cl_uint cl_gl_context_info; +typedef cl_mem CL_API_CALL +clCreateFromGLTexture2D_t( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret); -/* Additional Error Codes */ -#define CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR -1000 +typedef clCreateFromGLTexture2D_t * +clCreateFromGLTexture2D_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; -/* cl_gl_context_info */ -#define CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR 0x2006 -#define CL_DEVICES_FOR_GL_CONTEXT_KHR 0x2007 +typedef cl_mem CL_API_CALL +clCreateFromGLTexture3D_t( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret); -/* Additional cl_context_properties */ -#define CL_GL_CONTEXT_KHR 0x2008 -#define CL_EGL_DISPLAY_KHR 0x2009 -#define CL_GLX_DISPLAY_KHR 0x200A -#define CL_WGL_HDC_KHR 0x200B -#define CL_CGL_SHAREGROUP_KHR 0x200C +typedef clCreateFromGLTexture3D_t * +clCreateFromGLTexture3D_fn CL_API_SUFFIX__VERSION_1_1_DEPRECATED; -extern CL_API_ENTRY cl_int CL_API_CALL -clGetGLContextInfoKHR(const cl_context_properties * properties, - cl_gl_context_info param_name, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int (CL_API_CALL *clGetGLContextInfoKHR_fn)( - const cl_context_properties * properties, - cl_gl_context_info param_name, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret); - -/* - * cl_khr_gl_event extension - */ -#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromGLTexture2D( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +extern CL_API_ENTRY cl_mem CL_API_CALL +clCreateFromGLTexture3D( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_khr_gl_event +***************************************************************/ +#define cl_khr_gl_event 1 +#define CL_KHR_GL_EVENT_EXTENSION_NAME \ + "cl_khr_gl_event" + + +#define CL_KHR_GL_EVENT_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef struct __GLsync * cl_GLsync; + +/* cl_command_type */ +#define CL_COMMAND_GL_FENCE_SYNC_OBJECT_KHR 0x200D + + +typedef cl_event CL_API_CALL +clCreateEventFromGLsyncKHR_t( + cl_context context, + cl_GLsync sync, + cl_int* errcode_ret); + +typedef clCreateEventFromGLsyncKHR_t * +clCreateEventFromGLsyncKHR_fn CL_API_SUFFIX__VERSION_1_1; + +#if !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_event CL_API_CALL -clCreateEventFromGLsyncKHR(cl_context context, - cl_GLsync sync, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1; +clCreateEventFromGLsyncKHR( + cl_context context, + cl_GLsync sync, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1; + +#endif /* !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + +/*************************************************************** +* cl_khr_gl_depth_images +***************************************************************/ +#define cl_khr_gl_depth_images 1 +#define CL_KHR_GL_DEPTH_IMAGES_EXTENSION_NAME \ + "cl_khr_gl_depth_images" + + +#define CL_KHR_GL_DEPTH_IMAGES_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* cl_channel_order */ +#define CL_DEPTH_STENCIL 0x10BE + +/* cl_channel_type */ +#define CL_UNORM_INT24 0x10DF + +/*************************************************************** +* cl_khr_gl_msaa_sharing +***************************************************************/ +#define cl_khr_gl_msaa_sharing 1 +#define CL_KHR_GL_MSAA_SHARING_EXTENSION_NAME \ + "cl_khr_gl_msaa_sharing" + + +#define CL_KHR_GL_MSAA_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +/* cl_gl_texture_info */ +#define CL_GL_NUM_SAMPLES 0x2012 /*************************************************************** * cl_intel_sharing_format_query_gl ***************************************************************/ #define cl_intel_sharing_format_query_gl 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_GL_EXTENSION_NAME \ + "cl_intel_sharing_format_query_gl" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_GL_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* when cl_khr_gl_sharing is supported */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSupportedGLTextureFormatsINTEL( +typedef cl_int CL_API_CALL +clGetSupportedGLTextureFormatsINTEL_t( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, cl_GLenum* gl_formats, - cl_uint* num_texture_formats) ; + cl_uint* num_texture_formats); + +typedef clGetSupportedGLTextureFormatsINTEL_t * +clGetSupportedGLTextureFormatsINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) -typedef cl_int (CL_API_CALL * -clGetSupportedGLTextureFormatsINTEL_fn)( +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedGLTextureFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -187,8 +412,10 @@ clGetSupportedGLTextureFormatsINTEL_fn)( cl_GLenum* gl_formats, cl_uint* num_texture_formats) ; +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ + #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_GL_H */ +#endif /* OPENCL_CL_GL_H_ */ diff --git a/deps/opencl-headers/CL/cl_gl_ext.h b/deps/opencl-headers/CL/cl_gl_ext.h index 8ec818167..b5da13eb6 100644 --- a/deps/opencl-headers/CL/cl_gl_ext.h +++ b/deps/opencl-headers/CL/cl_gl_ext.h @@ -15,4 +15,4 @@ ******************************************************************************/ #include -#pragma message("All OpenGL-related extensions have been moved into cl_gl.h. Please include cl_gl.h directly.") +#pragma message("The extensions in cl_gl_ext.h have been moved into cl_gl.h. Please include cl_gl.h directly.") diff --git a/deps/opencl-headers/CL/cl_icd.h b/deps/opencl-headers/CL/cl_icd.h index 360b87030..435ad4832 100644 --- a/deps/opencl-headers/CL/cl_icd.h +++ b/deps/opencl-headers/CL/cl_icd.h @@ -18,6 +18,7 @@ #define OPENCL_CL_ICD_H #include +#include #include #include #include @@ -32,1258 +33,278 @@ extern "C" { #endif -/* - * This file contains pointer type definitions for each of the CL API calls as - * well as a type definition for the dispatch table used by the Khronos ICD - * loader (see cl_khr_icd extension specification for background). - */ - -/* API function pointer definitions */ - -// Platform APIs -typedef cl_int(CL_API_CALL *cl_api_clGetPlatformIDs)( - cl_uint num_entries, cl_platform_id *platforms, - cl_uint *num_platforms) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetPlatformInfo)( - cl_platform_id platform, cl_platform_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -// Device APIs -typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDs)( - cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, - cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetDeviceInfo)( - cl_device_id device, cl_device_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clCreateSubDevices)( - cl_device_id in_device, - const cl_device_partition_property *partition_properties, - cl_uint num_entries, cl_device_id *out_devices, cl_uint *num_devices); - -typedef cl_int(CL_API_CALL *cl_api_clRetainDevice)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseDevice)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clCreateSubDevices; -typedef void *cl_api_clRetainDevice; -typedef void *cl_api_clReleaseDevice; - -#endif - -// Context APIs -typedef cl_context(CL_API_CALL *cl_api_clCreateContext)( - const cl_context_properties *properties, cl_uint num_devices, - const cl_device_id *devices, - void(CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), - void *user_data, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_context(CL_API_CALL *cl_api_clCreateContextFromType)( - const cl_context_properties *properties, cl_device_type device_type, - void(CL_CALLBACK *pfn_notify)(const char *, const void *, size_t, void *), - void *user_data, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clRetainContext)( - cl_context context) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseContext)( - cl_context context) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetContextInfo)( - cl_context context, cl_context_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -// Command Queue APIs -typedef cl_command_queue(CL_API_CALL *cl_api_clCreateCommandQueue)( - cl_context context, cl_device_id device, - cl_command_queue_properties properties, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_2_0 - -typedef -cl_command_queue(CL_API_CALL *cl_api_clCreateCommandQueueWithProperties)( - cl_context /* context */, cl_device_id /* device */, - const cl_queue_properties * /* properties */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; - -#else - -typedef void *cl_api_clCreateCommandQueueWithProperties; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clRetainCommandQueue)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseCommandQueue)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetCommandQueueInfo)( - cl_command_queue command_queue, cl_command_queue_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -// Memory Object APIs -typedef cl_mem(CL_API_CALL *cl_api_clCreateBuffer)( - cl_context context, cl_mem_flags flags, size_t size, void *host_ptr, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_mem(CL_API_CALL *cl_api_clCreateImage)( - cl_context context, cl_mem_flags flags, const cl_image_format *image_format, - const cl_image_desc *image_desc, void *host_ptr, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clCreateImage; - -#endif - -#ifdef CL_VERSION_3_0 - -typedef cl_mem(CL_API_CALL *cl_api_clCreateBufferWithProperties)( - cl_context context, const cl_mem_properties *properties, cl_mem_flags flags, - size_t size, void *host_ptr, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_3_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateImageWithProperties)( - cl_context context, const cl_mem_properties *properties, cl_mem_flags flags, - const cl_image_format *image_format, const cl_image_desc *image_desc, - void *host_ptr, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_3_0; - -typedef cl_int(CL_API_CALL* cl_api_clSetContextDestructorCallback)( - cl_context context, - void(CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), - void* user_data) CL_API_SUFFIX__VERSION_3_0; - -#else - -typedef void *cl_api_clCreateBufferWithProperties; -typedef void *cl_api_clCreateImageWithProperties; -typedef void *cl_api_clSetContextDestructorCallback; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clRetainMemObject)( - cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseMemObject)( - cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetSupportedImageFormats)( - cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, - cl_uint num_entries, cl_image_format *image_formats, - cl_uint *num_image_formats) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetMemObjectInfo)( - cl_mem memobj, cl_mem_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetImageInfo)( - cl_mem image, cl_image_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_2_0 - -typedef cl_mem(CL_API_CALL *cl_api_clCreatePipe)( - cl_context /* context */, cl_mem_flags /* flags */, - cl_uint /* pipe_packet_size */, cl_uint /* pipe_max_packets */, - const cl_pipe_properties * /* properties */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetPipeInfo)( - cl_mem /* pipe */, cl_pipe_info /* param_name */, - size_t /* param_value_size */, void * /* param_value */, - size_t * /* param_value_size_ret */) CL_API_SUFFIX__VERSION_2_0; - -typedef void *(CL_API_CALL *cl_api_clSVMAlloc)( - cl_context /* context */, cl_svm_mem_flags /* flags */, size_t /* size */, - unsigned int /* alignment */)CL_API_SUFFIX__VERSION_2_0; - -typedef void(CL_API_CALL *cl_api_clSVMFree)( - cl_context /* context */, - void * /* svm_pointer */) CL_API_SUFFIX__VERSION_2_0; - -#else - -typedef void *cl_api_clCreatePipe; -typedef void *cl_api_clGetPipeInfo; -typedef void *cl_api_clSVMAlloc; -typedef void *cl_api_clSVMFree; - -#endif - -// Sampler APIs -typedef cl_sampler(CL_API_CALL *cl_api_clCreateSampler)( - cl_context context, cl_bool normalized_coords, - cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clRetainSampler)( - cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseSampler)( - cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetSamplerInfo)( - cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_2_0 - -typedef -cl_sampler(CL_API_CALL *cl_api_clCreateSamplerWithProperties)( - cl_context /* context */, - const cl_sampler_properties * /* sampler_properties */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; - -#else - -typedef void *cl_api_clCreateSamplerWithProperties; - -#endif - -// Program Object APIs -typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithSource)( - cl_context context, cl_uint count, const char **strings, - const size_t *lengths, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithBinary)( - cl_context context, cl_uint num_devices, const cl_device_id *device_list, - const size_t *lengths, const unsigned char **binaries, - cl_int *binary_status, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef -cl_program(CL_API_CALL *cl_api_clCreateProgramWithBuiltInKernels)( - cl_context context, cl_uint num_devices, const cl_device_id *device_list, - const char *kernel_names, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clCreateProgramWithBuiltInKernels; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clRetainProgram)( - cl_program program) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseProgram)( - cl_program program) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clBuildProgram)( - cl_program program, cl_uint num_devices, const cl_device_id *device_list, - const char *options, - void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), - void *user_data) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clCompileProgram)( - cl_program program, cl_uint num_devices, const cl_device_id *device_list, - const char *options, cl_uint num_input_headers, - const cl_program *input_headers, const char **header_include_names, - void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), - void *user_data) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_program(CL_API_CALL *cl_api_clLinkProgram)( - cl_context context, cl_uint num_devices, const cl_device_id *device_list, - const char *options, cl_uint num_input_programs, - const cl_program *input_programs, - void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), - void *user_data, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clCompileProgram; -typedef void *cl_api_clLinkProgram; - -#endif - -#ifdef CL_VERSION_2_2 - -typedef -cl_int(CL_API_CALL *cl_api_clSetProgramSpecializationConstant)( - cl_program program, cl_uint spec_id, size_t spec_size, - const void *spec_value) CL_API_SUFFIX__VERSION_2_2; - -typedef cl_int(CL_API_CALL *cl_api_clSetProgramReleaseCallback)( - cl_program program, - void(CL_CALLBACK *pfn_notify)(cl_program program, void *user_data), - void *user_data) CL_API_SUFFIX__VERSION_2_2; - -#else - -typedef void *cl_api_clSetProgramSpecializationConstant; -typedef void *cl_api_clSetProgramReleaseCallback; - -#endif - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clUnloadPlatformCompiler)( - cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clUnloadPlatformCompiler; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clGetProgramInfo)( - cl_program program, cl_program_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetProgramBuildInfo)( - cl_program program, cl_device_id device, cl_program_build_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -// Kernel Object APIs -typedef cl_kernel(CL_API_CALL *cl_api_clCreateKernel)( - cl_program program, const char *kernel_name, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clCreateKernelsInProgram)( - cl_program program, cl_uint num_kernels, cl_kernel *kernels, - cl_uint *num_kernels_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clRetainKernel)( - cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseKernel)( - cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clSetKernelArg)( - cl_kernel kernel, cl_uint arg_index, size_t arg_size, - const void *arg_value) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetKernelInfo)( - cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clGetKernelArgInfo)( - cl_kernel kernel, cl_uint arg_indx, cl_kernel_arg_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clGetKernelArgInfo; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clGetKernelWorkGroupInfo)( - cl_kernel kernel, cl_device_id device, cl_kernel_work_group_info param_name, - size_t param_value_size, void *param_value, - size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_2_0 - -typedef cl_int(CL_API_CALL *cl_api_clSetKernelArgSVMPointer)( - cl_kernel /* kernel */, cl_uint /* arg_index */, - const void * /* arg_value */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clSetKernelExecInfo)( - cl_kernel /* kernel */, cl_kernel_exec_info /* param_name */, - size_t /* param_value_size */, - const void * /* param_value */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetKernelSubGroupInfoKHR)( - cl_kernel /* in_kernel */, cl_device_id /*in_device*/, - cl_kernel_sub_group_info /* param_name */, size_t /*input_value_size*/, - const void * /*input_value*/, size_t /*param_value_size*/, - void * /*param_value*/, - size_t * /*param_value_size_ret*/) CL_API_SUFFIX__VERSION_2_0; - -#else - -typedef void *cl_api_clSetKernelArgSVMPointer; -typedef void *cl_api_clSetKernelExecInfo; -typedef void *cl_api_clGetKernelSubGroupInfoKHR; - -#endif - -// Event Object APIs -typedef cl_int(CL_API_CALL *cl_api_clWaitForEvents)( - cl_uint num_events, const cl_event *event_list) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetEventInfo)( - cl_event event, cl_event_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clRetainEvent)(cl_event event) - CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseEvent)(cl_event event) - CL_API_SUFFIX__VERSION_1_0; - -// Profiling APIs -typedef cl_int(CL_API_CALL *cl_api_clGetEventProfilingInfo)( - cl_event event, cl_profiling_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -// Flush and Finish APIs -typedef cl_int(CL_API_CALL *cl_api_clFlush)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clFinish)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -// Enqueued Commands APIs -typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadBuffer)( - cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, - size_t offset, size_t cb, void *ptr, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_1 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadBufferRect)( - cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, - const size_t *buffer_origin, const size_t *host_origin, - const size_t *region, size_t buffer_row_pitch, size_t buffer_slice_pitch, - size_t host_row_pitch, size_t host_slice_pitch, void *ptr, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_1; - -#else - -typedef void *cl_api_clEnqueueReadBufferRect; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueWriteBuffer)( - cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, - size_t offset, size_t cb, const void *ptr, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_1 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueWriteBufferRect)( - cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, - const size_t *buffer_origin, const size_t *host_origin, - const size_t *region, size_t buffer_row_pitch, size_t buffer_slice_pitch, - size_t host_row_pitch, size_t host_slice_pitch, const void *ptr, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_1; - -#else - -typedef void *cl_api_clEnqueueWriteBufferRect; - -#endif - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueFillBuffer)( - cl_command_queue command_queue, cl_mem buffer, const void *pattern, - size_t pattern_size, size_t offset, size_t cb, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clEnqueueFillBuffer; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyBuffer)( - cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, - size_t src_offset, size_t dst_offset, size_t cb, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_1 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyBufferRect)( - cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, - const size_t *src_origin, const size_t *dst_origin, const size_t *region, - size_t src_row_pitch, size_t src_slice_pitch, size_t dst_row_pitch, - size_t dst_slice_pitch, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_1; - -#else - -typedef void *cl_api_clEnqueueCopyBufferRect; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueReadImage)( - cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, - const size_t *origin, const size_t *region, size_t row_pitch, - size_t slice_pitch, void *ptr, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueWriteImage)( - cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, - const size_t *origin, const size_t *region, size_t input_row_pitch, - size_t input_slice_pitch, const void *ptr, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueFillImage)( - cl_command_queue command_queue, cl_mem image, const void *fill_color, - const size_t origin[3], const size_t region[3], - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clEnqueueFillImage; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyImage)( - cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, - const size_t *src_origin, const size_t *dst_origin, const size_t *region, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyImageToBuffer)( - cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, - const size_t *src_origin, const size_t *region, size_t dst_offset, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueCopyBufferToImage)( - cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, - size_t src_offset, const size_t *dst_origin, const size_t *region, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef void *(CL_API_CALL *cl_api_clEnqueueMapBuffer)( - cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, - cl_map_flags map_flags, size_t offset, size_t cb, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event, cl_int *errcode_ret)CL_API_SUFFIX__VERSION_1_0; - -typedef void *(CL_API_CALL *cl_api_clEnqueueMapImage)( - cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, - cl_map_flags map_flags, const size_t *origin, const size_t *region, - size_t *image_row_pitch, size_t *image_slice_pitch, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event, cl_int *errcode_ret)CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueUnmapMemObject)( - cl_command_queue command_queue, cl_mem memobj, void *mapped_ptr, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueMigrateMemObjects)( - cl_command_queue command_queue, cl_uint num_mem_objects, - const cl_mem *mem_objects, cl_mem_migration_flags flags, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clEnqueueMigrateMemObjects; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueNDRangeKernel)( - cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, - const size_t *global_work_offset, const size_t *global_work_size, - const size_t *local_work_size, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueTask)( - cl_command_queue command_queue, cl_kernel kernel, - cl_uint num_events_in_wait_list, const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueNativeKernel)( - cl_command_queue command_queue, void(CL_CALLBACK *user_func)(void *), - void *args, size_t cb_args, cl_uint num_mem_objects, const cl_mem *mem_list, - const void **args_mem_loc, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -#ifdef CL_VERSION_1_2 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueMarkerWithWaitList)( - cl_command_queue command_queue, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueBarrierWithWaitList)( - cl_command_queue command_queue, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -typedef void *( - CL_API_CALL *cl_api_clGetExtensionFunctionAddressForPlatform)( - cl_platform_id platform, - const char *function_name)CL_API_SUFFIX__VERSION_1_2; - -#else - -typedef void *cl_api_clEnqueueMarkerWithWaitList; -typedef void *cl_api_clEnqueueBarrierWithWaitList; -typedef void *cl_api_clGetExtensionFunctionAddressForPlatform; - -#endif - -// Shared Virtual Memory APIs - -#ifdef CL_VERSION_2_0 - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMFree)( - cl_command_queue /* command_queue */, cl_uint /* num_svm_pointers */, - void ** /* svm_pointers */, - void(CL_CALLBACK *pfn_free_func)(cl_command_queue /* queue */, - cl_uint /* num_svm_pointers */, - void ** /* svm_pointers[] */, - void * /* user_data */), - void * /* user_data */, cl_uint /* num_events_in_wait_list */, - const cl_event * /* event_wait_list */, - cl_event * /* event */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMMemcpy)( - cl_command_queue /* command_queue */, cl_bool /* blocking_copy */, - void * /* dst_ptr */, const void * /* src_ptr */, size_t /* size */, - cl_uint /* num_events_in_wait_list */, - const cl_event * /* event_wait_list */, - cl_event * /* event */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMMemFill)( - cl_command_queue /* command_queue */, void * /* svm_ptr */, - const void * /* pattern */, size_t /* pattern_size */, size_t /* size */, - cl_uint /* num_events_in_wait_list */, - const cl_event * /* event_wait_list */, - cl_event * /* event */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMMap)( - cl_command_queue /* command_queue */, cl_bool /* blocking_map */, - cl_map_flags /* map_flags */, void * /* svm_ptr */, size_t /* size */, - cl_uint /* num_events_in_wait_list */, - const cl_event * /* event_wait_list */, - cl_event * /* event */) CL_API_SUFFIX__VERSION_2_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMUnmap)( - cl_command_queue /* command_queue */, void * /* svm_ptr */, - cl_uint /* num_events_in_wait_list */, - const cl_event * /* event_wait_list */, - cl_event * /* event */) CL_API_SUFFIX__VERSION_2_0; - -#else - -typedef void *cl_api_clEnqueueSVMFree; -typedef void *cl_api_clEnqueueSVMMemcpy; -typedef void *cl_api_clEnqueueSVMMemFill; -typedef void *cl_api_clEnqueueSVMMap; -typedef void *cl_api_clEnqueueSVMUnmap; - -#endif - -// Deprecated APIs -typedef cl_int(CL_API_CALL *cl_api_clSetCommandQueueProperty)( - cl_command_queue command_queue, cl_command_queue_properties properties, - cl_bool enable, cl_command_queue_properties *old_properties) - CL_API_SUFFIX__VERSION_1_0_DEPRECATED; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateImage2D)( - cl_context context, cl_mem_flags flags, const cl_image_format *image_format, - size_t image_width, size_t image_height, size_t image_row_pitch, - void *host_ptr, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateImage3D)( - cl_context context, cl_mem_flags flags, const cl_image_format *image_format, - size_t image_width, size_t image_height, size_t image_depth, - size_t image_row_pitch, size_t image_slice_pitch, void *host_ptr, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef cl_int(CL_API_CALL *cl_api_clUnloadCompiler)(void) - CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueMarker)( - cl_command_queue command_queue, - cl_event *event) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueWaitForEvents)( - cl_command_queue command_queue, cl_uint num_events, - const cl_event *event_list) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueBarrier)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef void *(CL_API_CALL *cl_api_clGetExtensionFunctionAddress)( - const char *function_name)CL_API_SUFFIX__VERSION_1_1_DEPRECATED; - -// GL and other APIs -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLBuffer)( - cl_context context, cl_mem_flags flags, cl_GLuint bufobj, - int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLTexture)( - cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, - cl_GLuint texture, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLTexture2D)( - cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, - cl_GLuint texture, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLTexture3D)( - cl_context context, cl_mem_flags flags, cl_GLenum target, cl_GLint miplevel, - cl_GLuint texture, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromGLRenderbuffer)( - cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetGLObjectInfo)( - cl_mem memobj, cl_gl_object_type *gl_object_type, - cl_GLuint *gl_object_name) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clGetGLTextureInfo)( - cl_mem memobj, cl_gl_texture_info param_name, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueAcquireGLObjects)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueReleaseGLObjects)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -/* cl_khr_gl_sharing */ -typedef cl_int(CL_API_CALL *cl_api_clGetGLContextInfoKHR)( - const cl_context_properties *properties, cl_gl_context_info param_name, - size_t param_value_size, void *param_value, size_t *param_value_size_ret); - -/* cl_khr_gl_event */ -typedef cl_event(CL_API_CALL *cl_api_clCreateEventFromGLsyncKHR)( - cl_context context, cl_GLsync sync, cl_int *errcode_ret); - -#if defined(_WIN32) - -/* cl_khr_d3d10_sharing */ - -typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromD3D10KHR)( - cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, - void *d3d_object, cl_d3d10_device_set_khr d3d_device_set, - cl_uint num_entries, cl_device_id *devices, - cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10BufferKHR)( - cl_context context, cl_mem_flags flags, ID3D10Buffer *resource, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10Texture2DKHR)( - cl_context context, cl_mem_flags flags, ID3D10Texture2D *resource, - UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D10Texture3DKHR)( - cl_context context, cl_mem_flags flags, ID3D10Texture3D *resource, - UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueAcquireD3D10ObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueReleaseD3D10ObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_0; - -extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR( - cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, - void *d3d_object, cl_d3d10_device_set_khr d3d_device_set, - cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); - -extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D10BufferKHR(cl_context context, cl_mem_flags flags, - ID3D10Buffer *resource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( - cl_context context, cl_mem_flags flags, ID3D10Texture2D *resource, - UINT subresource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( - cl_context context, cl_mem_flags flags, ID3D10Texture3D *resource, - UINT subresource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -/* cl_khr_d3d11_sharing */ -typedef cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromD3D11KHR)( - cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, - void *d3d_object, cl_d3d11_device_set_khr d3d_device_set, - cl_uint num_entries, cl_device_id *devices, - cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11BufferKHR)( - cl_context context, cl_mem_flags flags, ID3D11Buffer *resource, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11Texture2DKHR)( - cl_context context, cl_mem_flags flags, ID3D11Texture2D *resource, - UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromD3D11Texture3DKHR)( - cl_context context, cl_mem_flags flags, ID3D11Texture3D *resource, - UINT subresource, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueAcquireD3D11ObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueReleaseD3D11ObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -/* cl_khr_dx9_media_sharing */ -typedef -cl_int(CL_API_CALL *cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR)( - cl_platform_id platform, cl_uint num_media_adapters, - cl_dx9_media_adapter_type_khr *media_adapters_type, void *media_adapters, - cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, - cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromDX9MediaSurfaceKHR)( - cl_context context, cl_mem_flags flags, - cl_dx9_media_adapter_type_khr adapter_type, void *surface_info, - cl_uint plane, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueAcquireDX9MediaSurfacesKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -typedef -cl_int(CL_API_CALL *cl_api_clEnqueueReleaseDX9MediaSurfacesKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_1_2; - -/* cl_khr_d3d11_sharing */ -extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR( - cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, - void *d3d_object, cl_d3d11_device_set_khr d3d_device_set, - cl_uint num_entries, cl_device_id *devices, cl_uint *num_devices); - -extern CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D11BufferKHR(cl_context context, cl_mem_flags flags, - ID3D11Buffer *resource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( - cl_context context, cl_mem_flags flags, ID3D11Texture2D *resource, - UINT subresource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( - cl_context context, cl_mem_flags flags, ID3D11Texture3D *resource, - UINT subresource, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -/* cl_khr_dx9_media_sharing */ -extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR( - cl_platform_id platform, cl_uint num_media_adapters, - cl_dx9_media_adapter_type_khr *media_adapter_type, void *media_adapters, - cl_dx9_media_adapter_set_khr media_adapter_set, cl_uint num_entries, - cl_device_id *devices, cl_uint *num_devices); - -extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR( - cl_context context, cl_mem_flags flags, - cl_dx9_media_adapter_type_khr adapter_type, void *surface_info, - cl_uint plane, cl_int *errcode_ret); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -#else - -/* cl_khr_d3d10_sharing */ -typedef void *cl_api_clGetDeviceIDsFromD3D10KHR; -typedef void *cl_api_clCreateFromD3D10BufferKHR; -typedef void *cl_api_clCreateFromD3D10Texture2DKHR; -typedef void *cl_api_clCreateFromD3D10Texture3DKHR; -typedef void *cl_api_clEnqueueAcquireD3D10ObjectsKHR; -typedef void *cl_api_clEnqueueReleaseD3D10ObjectsKHR; - -/* cl_khr_d3d11_sharing */ -typedef void *cl_api_clGetDeviceIDsFromD3D11KHR; -typedef void *cl_api_clCreateFromD3D11BufferKHR; -typedef void *cl_api_clCreateFromD3D11Texture2DKHR; -typedef void *cl_api_clCreateFromD3D11Texture3DKHR; -typedef void *cl_api_clEnqueueAcquireD3D11ObjectsKHR; -typedef void *cl_api_clEnqueueReleaseD3D11ObjectsKHR; - -/* cl_khr_dx9_media_sharing */ -typedef void *cl_api_clCreateFromDX9MediaSurfaceKHR; -typedef void *cl_api_clEnqueueAcquireDX9MediaSurfacesKHR; -typedef void *cl_api_clEnqueueReleaseDX9MediaSurfacesKHR; -typedef void *cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR; - -#endif - -/* OpenCL 1.1 */ - -#ifdef CL_VERSION_1_1 - -typedef cl_int(CL_API_CALL *cl_api_clSetEventCallback)( - cl_event /* event */, cl_int /* command_exec_callback_type */, - void(CL_CALLBACK * /* pfn_notify */)(cl_event, cl_int, void *), - void * /* user_data */) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_mem(CL_API_CALL *cl_api_clCreateSubBuffer)( - cl_mem /* buffer */, cl_mem_flags /* flags */, - cl_buffer_create_type /* buffer_create_type */, - const void * /* buffer_create_info */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; - -typedef -cl_int(CL_API_CALL *cl_api_clSetMemObjectDestructorCallback)( - cl_mem /* memobj */, - void(CL_CALLBACK * /*pfn_notify*/)(cl_mem /* memobj */, - void * /*user_data*/), - void * /*user_data */) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_event(CL_API_CALL *cl_api_clCreateUserEvent)( - cl_context /* context */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; - -typedef cl_int(CL_API_CALL *cl_api_clSetUserEventStatus)( - cl_event /* event */, - cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; - -#else - -typedef void *cl_api_clSetEventCallback; -typedef void *cl_api_clCreateSubBuffer; -typedef void *cl_api_clSetMemObjectDestructorCallback; -typedef void *cl_api_clCreateUserEvent; -typedef void *cl_api_clSetUserEventStatus; - -#endif - -typedef cl_int(CL_API_CALL *cl_api_clCreateSubDevicesEXT)( - cl_device_id in_device, - const cl_device_partition_property_ext *partition_properties, - cl_uint num_entries, cl_device_id *out_devices, cl_uint *num_devices); - -typedef cl_int(CL_API_CALL *cl_api_clRetainDeviceEXT)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_0; - -typedef cl_int(CL_API_CALL *cl_api_clReleaseDeviceEXT)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_0; - -/* cl_khr_egl_image */ -typedef cl_mem(CL_API_CALL *cl_api_clCreateFromEGLImageKHR)( - cl_context context, CLeglDisplayKHR display, CLeglImageKHR image, - cl_mem_flags flags, const cl_egl_image_properties_khr *properties, - cl_int *errcode_ret); - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueAcquireEGLObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueReleaseEGLObjectsKHR)( - cl_command_queue command_queue, cl_uint num_objects, - const cl_mem *mem_objects, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, cl_event *event); - -/* cl_khr_egl_event */ -typedef cl_event(CL_API_CALL *cl_api_clCreateEventFromEGLSyncKHR)( - cl_context context, CLeglSyncKHR sync, CLeglDisplayKHR display, - cl_int *errcode_ret); - -#ifdef CL_VERSION_2_1 - -typedef cl_int(CL_API_CALL *cl_api_clSetDefaultDeviceCommandQueue)( - cl_context context, cl_device_id device, - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_program(CL_API_CALL *cl_api_clCreateProgramWithIL)( - cl_context context, const void *il, size_t length, - cl_int *errcode_ret) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_int(CL_API_CALL *cl_api_clGetKernelSubGroupInfo)( - cl_kernel kernel, cl_device_id device, cl_kernel_sub_group_info param_name, - size_t input_value_size, const void *input_value, size_t param_value_size, - void *param_value, size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_kernel(CL_API_CALL *cl_api_clCloneKernel)( - cl_kernel source_kernel, cl_int *errcode_ret) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_int(CL_API_CALL *cl_api_clEnqueueSVMMigrateMem)( - cl_command_queue command_queue, cl_uint num_svm_pointers, - const void **svm_pointers, const size_t *sizes, - cl_mem_migration_flags flags, cl_uint num_events_in_wait_list, - const cl_event *event_wait_list, - cl_event *event) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_int(CL_API_CALL *cl_api_clGetDeviceAndHostTimer)( - cl_device_id device, cl_ulong *device_timestamp, - cl_ulong *host_timestamp) CL_API_SUFFIX__VERSION_2_1; - -typedef cl_int(CL_API_CALL *cl_api_clGetHostTimer)( - cl_device_id device, cl_ulong *host_timestamp) CL_API_SUFFIX__VERSION_2_1; - -#else - -typedef void *cl_api_clSetDefaultDeviceCommandQueue; -typedef void *cl_api_clCreateProgramWithIL; -typedef void *cl_api_clGetKernelSubGroupInfo; -typedef void *cl_api_clCloneKernel; -typedef void *cl_api_clEnqueueSVMMigrateMem; -typedef void *cl_api_clGetDeviceAndHostTimer; -typedef void *cl_api_clGetHostTimer; - -#endif - /* Vendor dispatch table structure */ typedef struct _cl_icd_dispatch { /* OpenCL 1.0 */ - cl_api_clGetPlatformIDs clGetPlatformIDs; - cl_api_clGetPlatformInfo clGetPlatformInfo; - cl_api_clGetDeviceIDs clGetDeviceIDs; - cl_api_clGetDeviceInfo clGetDeviceInfo; - cl_api_clCreateContext clCreateContext; - cl_api_clCreateContextFromType clCreateContextFromType; - cl_api_clRetainContext clRetainContext; - cl_api_clReleaseContext clReleaseContext; - cl_api_clGetContextInfo clGetContextInfo; - cl_api_clCreateCommandQueue clCreateCommandQueue; - cl_api_clRetainCommandQueue clRetainCommandQueue; - cl_api_clReleaseCommandQueue clReleaseCommandQueue; - cl_api_clGetCommandQueueInfo clGetCommandQueueInfo; - cl_api_clSetCommandQueueProperty clSetCommandQueueProperty; - cl_api_clCreateBuffer clCreateBuffer; - cl_api_clCreateImage2D clCreateImage2D; - cl_api_clCreateImage3D clCreateImage3D; - cl_api_clRetainMemObject clRetainMemObject; - cl_api_clReleaseMemObject clReleaseMemObject; - cl_api_clGetSupportedImageFormats clGetSupportedImageFormats; - cl_api_clGetMemObjectInfo clGetMemObjectInfo; - cl_api_clGetImageInfo clGetImageInfo; - cl_api_clCreateSampler clCreateSampler; - cl_api_clRetainSampler clRetainSampler; - cl_api_clReleaseSampler clReleaseSampler; - cl_api_clGetSamplerInfo clGetSamplerInfo; - cl_api_clCreateProgramWithSource clCreateProgramWithSource; - cl_api_clCreateProgramWithBinary clCreateProgramWithBinary; - cl_api_clRetainProgram clRetainProgram; - cl_api_clReleaseProgram clReleaseProgram; - cl_api_clBuildProgram clBuildProgram; - cl_api_clUnloadCompiler clUnloadCompiler; - cl_api_clGetProgramInfo clGetProgramInfo; - cl_api_clGetProgramBuildInfo clGetProgramBuildInfo; - cl_api_clCreateKernel clCreateKernel; - cl_api_clCreateKernelsInProgram clCreateKernelsInProgram; - cl_api_clRetainKernel clRetainKernel; - cl_api_clReleaseKernel clReleaseKernel; - cl_api_clSetKernelArg clSetKernelArg; - cl_api_clGetKernelInfo clGetKernelInfo; - cl_api_clGetKernelWorkGroupInfo clGetKernelWorkGroupInfo; - cl_api_clWaitForEvents clWaitForEvents; - cl_api_clGetEventInfo clGetEventInfo; - cl_api_clRetainEvent clRetainEvent; - cl_api_clReleaseEvent clReleaseEvent; - cl_api_clGetEventProfilingInfo clGetEventProfilingInfo; - cl_api_clFlush clFlush; - cl_api_clFinish clFinish; - cl_api_clEnqueueReadBuffer clEnqueueReadBuffer; - cl_api_clEnqueueWriteBuffer clEnqueueWriteBuffer; - cl_api_clEnqueueCopyBuffer clEnqueueCopyBuffer; - cl_api_clEnqueueReadImage clEnqueueReadImage; - cl_api_clEnqueueWriteImage clEnqueueWriteImage; - cl_api_clEnqueueCopyImage clEnqueueCopyImage; - cl_api_clEnqueueCopyImageToBuffer clEnqueueCopyImageToBuffer; - cl_api_clEnqueueCopyBufferToImage clEnqueueCopyBufferToImage; - cl_api_clEnqueueMapBuffer clEnqueueMapBuffer; - cl_api_clEnqueueMapImage clEnqueueMapImage; - cl_api_clEnqueueUnmapMemObject clEnqueueUnmapMemObject; - cl_api_clEnqueueNDRangeKernel clEnqueueNDRangeKernel; - cl_api_clEnqueueTask clEnqueueTask; - cl_api_clEnqueueNativeKernel clEnqueueNativeKernel; - cl_api_clEnqueueMarker clEnqueueMarker; - cl_api_clEnqueueWaitForEvents clEnqueueWaitForEvents; - cl_api_clEnqueueBarrier clEnqueueBarrier; - cl_api_clGetExtensionFunctionAddress clGetExtensionFunctionAddress; - cl_api_clCreateFromGLBuffer clCreateFromGLBuffer; - cl_api_clCreateFromGLTexture2D clCreateFromGLTexture2D; - cl_api_clCreateFromGLTexture3D clCreateFromGLTexture3D; - cl_api_clCreateFromGLRenderbuffer clCreateFromGLRenderbuffer; - cl_api_clGetGLObjectInfo clGetGLObjectInfo; - cl_api_clGetGLTextureInfo clGetGLTextureInfo; - cl_api_clEnqueueAcquireGLObjects clEnqueueAcquireGLObjects; - cl_api_clEnqueueReleaseGLObjects clEnqueueReleaseGLObjects; - cl_api_clGetGLContextInfoKHR clGetGLContextInfoKHR; + clGetPlatformIDs_t *clGetPlatformIDs; + clGetPlatformInfo_t *clGetPlatformInfo; + clGetDeviceIDs_t *clGetDeviceIDs; + clGetDeviceInfo_t *clGetDeviceInfo; + clCreateContext_t *clCreateContext; + clCreateContextFromType_t *clCreateContextFromType; + clRetainContext_t *clRetainContext; + clReleaseContext_t *clReleaseContext; + clGetContextInfo_t *clGetContextInfo; + clCreateCommandQueue_t *clCreateCommandQueue; + clRetainCommandQueue_t *clRetainCommandQueue; + clReleaseCommandQueue_t *clReleaseCommandQueue; + clGetCommandQueueInfo_t *clGetCommandQueueInfo; + clSetCommandQueueProperty_t *clSetCommandQueueProperty; + clCreateBuffer_t *clCreateBuffer; + clCreateImage2D_t *clCreateImage2D; + clCreateImage3D_t *clCreateImage3D; + clRetainMemObject_t *clRetainMemObject; + clReleaseMemObject_t *clReleaseMemObject; + clGetSupportedImageFormats_t *clGetSupportedImageFormats; + clGetMemObjectInfo_t *clGetMemObjectInfo; + clGetImageInfo_t *clGetImageInfo; + clCreateSampler_t *clCreateSampler; + clRetainSampler_t *clRetainSampler; + clReleaseSampler_t *clReleaseSampler; + clGetSamplerInfo_t *clGetSamplerInfo; + clCreateProgramWithSource_t *clCreateProgramWithSource; + clCreateProgramWithBinary_t *clCreateProgramWithBinary; + clRetainProgram_t *clRetainProgram; + clReleaseProgram_t *clReleaseProgram; + clBuildProgram_t *clBuildProgram; + clUnloadCompiler_t *clUnloadCompiler; + clGetProgramInfo_t *clGetProgramInfo; + clGetProgramBuildInfo_t *clGetProgramBuildInfo; + clCreateKernel_t *clCreateKernel; + clCreateKernelsInProgram_t *clCreateKernelsInProgram; + clRetainKernel_t *clRetainKernel; + clReleaseKernel_t *clReleaseKernel; + clSetKernelArg_t *clSetKernelArg; + clGetKernelInfo_t *clGetKernelInfo; + clGetKernelWorkGroupInfo_t *clGetKernelWorkGroupInfo; + clWaitForEvents_t *clWaitForEvents; + clGetEventInfo_t *clGetEventInfo; + clRetainEvent_t *clRetainEvent; + clReleaseEvent_t *clReleaseEvent; + clGetEventProfilingInfo_t *clGetEventProfilingInfo; + clFlush_t *clFlush; + clFinish_t *clFinish; + clEnqueueReadBuffer_t *clEnqueueReadBuffer; + clEnqueueWriteBuffer_t *clEnqueueWriteBuffer; + clEnqueueCopyBuffer_t *clEnqueueCopyBuffer; + clEnqueueReadImage_t *clEnqueueReadImage; + clEnqueueWriteImage_t *clEnqueueWriteImage; + clEnqueueCopyImage_t *clEnqueueCopyImage; + clEnqueueCopyImageToBuffer_t *clEnqueueCopyImageToBuffer; + clEnqueueCopyBufferToImage_t *clEnqueueCopyBufferToImage; + clEnqueueMapBuffer_t *clEnqueueMapBuffer; + clEnqueueMapImage_t *clEnqueueMapImage; + clEnqueueUnmapMemObject_t *clEnqueueUnmapMemObject; + clEnqueueNDRangeKernel_t *clEnqueueNDRangeKernel; + clEnqueueTask_t *clEnqueueTask; + clEnqueueNativeKernel_t *clEnqueueNativeKernel; + clEnqueueMarker_t *clEnqueueMarker; + clEnqueueWaitForEvents_t *clEnqueueWaitForEvents; + clEnqueueBarrier_t *clEnqueueBarrier; + clGetExtensionFunctionAddress_t *clGetExtensionFunctionAddress; + clCreateFromGLBuffer_t *clCreateFromGLBuffer; + clCreateFromGLTexture2D_t *clCreateFromGLTexture2D; + clCreateFromGLTexture3D_t *clCreateFromGLTexture3D; + clCreateFromGLRenderbuffer_t *clCreateFromGLRenderbuffer; + clGetGLObjectInfo_t *clGetGLObjectInfo; + clGetGLTextureInfo_t *clGetGLTextureInfo; + clEnqueueAcquireGLObjects_t *clEnqueueAcquireGLObjects; + clEnqueueReleaseGLObjects_t *clEnqueueReleaseGLObjects; + clGetGLContextInfoKHR_t *clGetGLContextInfoKHR; /* cl_khr_d3d10_sharing */ - cl_api_clGetDeviceIDsFromD3D10KHR clGetDeviceIDsFromD3D10KHR; - cl_api_clCreateFromD3D10BufferKHR clCreateFromD3D10BufferKHR; - cl_api_clCreateFromD3D10Texture2DKHR clCreateFromD3D10Texture2DKHR; - cl_api_clCreateFromD3D10Texture3DKHR clCreateFromD3D10Texture3DKHR; - cl_api_clEnqueueAcquireD3D10ObjectsKHR clEnqueueAcquireD3D10ObjectsKHR; - cl_api_clEnqueueReleaseD3D10ObjectsKHR clEnqueueReleaseD3D10ObjectsKHR; +#ifdef _WIN32 + clGetDeviceIDsFromD3D10KHR_t *clGetDeviceIDsFromD3D10KHR; + clCreateFromD3D10BufferKHR_t *clCreateFromD3D10BufferKHR; + clCreateFromD3D10Texture2DKHR_t *clCreateFromD3D10Texture2DKHR; + clCreateFromD3D10Texture3DKHR_t *clCreateFromD3D10Texture3DKHR; + clEnqueueAcquireD3D10ObjectsKHR_t *clEnqueueAcquireD3D10ObjectsKHR; + clEnqueueReleaseD3D10ObjectsKHR_t *clEnqueueReleaseD3D10ObjectsKHR; +#else + void *clGetDeviceIDsFromD3D10KHR; + void *clCreateFromD3D10BufferKHR; + void *clCreateFromD3D10Texture2DKHR; + void *clCreateFromD3D10Texture3DKHR; + void *clEnqueueAcquireD3D10ObjectsKHR; + void *clEnqueueReleaseD3D10ObjectsKHR; +#endif /* OpenCL 1.1 */ - cl_api_clSetEventCallback clSetEventCallback; - cl_api_clCreateSubBuffer clCreateSubBuffer; - cl_api_clSetMemObjectDestructorCallback clSetMemObjectDestructorCallback; - cl_api_clCreateUserEvent clCreateUserEvent; - cl_api_clSetUserEventStatus clSetUserEventStatus; - cl_api_clEnqueueReadBufferRect clEnqueueReadBufferRect; - cl_api_clEnqueueWriteBufferRect clEnqueueWriteBufferRect; - cl_api_clEnqueueCopyBufferRect clEnqueueCopyBufferRect; +#ifdef CL_VERSION_1_1 + clSetEventCallback_t *clSetEventCallback; + clCreateSubBuffer_t *clCreateSubBuffer; + clSetMemObjectDestructorCallback_t *clSetMemObjectDestructorCallback; + clCreateUserEvent_t *clCreateUserEvent; + clSetUserEventStatus_t *clSetUserEventStatus; + clEnqueueReadBufferRect_t *clEnqueueReadBufferRect; + clEnqueueWriteBufferRect_t *clEnqueueWriteBufferRect; + clEnqueueCopyBufferRect_t *clEnqueueCopyBufferRect; +#else + void *clSetEventCallback; + void *clCreateSubBuffer; + void *clSetMemObjectDestructorCallback; + void *clCreateUserEvent; + void *clSetUserEventStatus; + void *clEnqueueReadBufferRect; + void *clEnqueueWriteBufferRect; + void *clEnqueueCopyBufferRect; +#endif /* cl_ext_device_fission */ - cl_api_clCreateSubDevicesEXT clCreateSubDevicesEXT; - cl_api_clRetainDeviceEXT clRetainDeviceEXT; - cl_api_clReleaseDeviceEXT clReleaseDeviceEXT; + clCreateSubDevicesEXT_t *clCreateSubDevicesEXT; + clRetainDeviceEXT_t *clRetainDeviceEXT; + clReleaseDeviceEXT_t *clReleaseDeviceEXT; /* cl_khr_gl_event */ - cl_api_clCreateEventFromGLsyncKHR clCreateEventFromGLsyncKHR; + clCreateEventFromGLsyncKHR_t *clCreateEventFromGLsyncKHR; /* OpenCL 1.2 */ - cl_api_clCreateSubDevices clCreateSubDevices; - cl_api_clRetainDevice clRetainDevice; - cl_api_clReleaseDevice clReleaseDevice; - cl_api_clCreateImage clCreateImage; - cl_api_clCreateProgramWithBuiltInKernels clCreateProgramWithBuiltInKernels; - cl_api_clCompileProgram clCompileProgram; - cl_api_clLinkProgram clLinkProgram; - cl_api_clUnloadPlatformCompiler clUnloadPlatformCompiler; - cl_api_clGetKernelArgInfo clGetKernelArgInfo; - cl_api_clEnqueueFillBuffer clEnqueueFillBuffer; - cl_api_clEnqueueFillImage clEnqueueFillImage; - cl_api_clEnqueueMigrateMemObjects clEnqueueMigrateMemObjects; - cl_api_clEnqueueMarkerWithWaitList clEnqueueMarkerWithWaitList; - cl_api_clEnqueueBarrierWithWaitList clEnqueueBarrierWithWaitList; - cl_api_clGetExtensionFunctionAddressForPlatform +#ifdef CL_VERSION_1_2 + clCreateSubDevices_t *clCreateSubDevices; + clRetainDevice_t *clRetainDevice; + clReleaseDevice_t *clReleaseDevice; + clCreateImage_t *clCreateImage; + clCreateProgramWithBuiltInKernels_t *clCreateProgramWithBuiltInKernels; + clCompileProgram_t *clCompileProgram; + clLinkProgram_t *clLinkProgram; + clUnloadPlatformCompiler_t *clUnloadPlatformCompiler; + clGetKernelArgInfo_t *clGetKernelArgInfo; + clEnqueueFillBuffer_t *clEnqueueFillBuffer; + clEnqueueFillImage_t *clEnqueueFillImage; + clEnqueueMigrateMemObjects_t *clEnqueueMigrateMemObjects; + clEnqueueMarkerWithWaitList_t *clEnqueueMarkerWithWaitList; + clEnqueueBarrierWithWaitList_t *clEnqueueBarrierWithWaitList; + clGetExtensionFunctionAddressForPlatform_t * clGetExtensionFunctionAddressForPlatform; - cl_api_clCreateFromGLTexture clCreateFromGLTexture; - - /* cl_khr_d3d11_sharing */ - cl_api_clGetDeviceIDsFromD3D11KHR clGetDeviceIDsFromD3D11KHR; - cl_api_clCreateFromD3D11BufferKHR clCreateFromD3D11BufferKHR; - cl_api_clCreateFromD3D11Texture2DKHR clCreateFromD3D11Texture2DKHR; - cl_api_clCreateFromD3D11Texture3DKHR clCreateFromD3D11Texture3DKHR; - cl_api_clCreateFromDX9MediaSurfaceKHR clCreateFromDX9MediaSurfaceKHR; - cl_api_clEnqueueAcquireD3D11ObjectsKHR clEnqueueAcquireD3D11ObjectsKHR; - cl_api_clEnqueueReleaseD3D11ObjectsKHR clEnqueueReleaseD3D11ObjectsKHR; + clCreateFromGLTexture_t *clCreateFromGLTexture; +#else + void *clCreateSubDevices; + void *clRetainDevice; + void *clReleaseDevice; + void *clCreateImage; + void *clCreateProgramWithBuiltInKernels; + void *clCompileProgram; + void *clLinkProgram; + void *clUnloadPlatformCompiler; + void *clGetKernelArgInfo; + void *clEnqueueFillBuffer; + void *clEnqueueFillImage; + void *clEnqueueMigrateMemObjects; + void *clEnqueueMarkerWithWaitList; + void *clEnqueueBarrierWithWaitList; + void *clGetExtensionFunctionAddressForPlatform; + void *clCreateFromGLTexture; +#endif - /* cl_khr_dx9_media_sharing */ - cl_api_clGetDeviceIDsFromDX9MediaAdapterKHR + /* cl_khr_d3d11_sharing and cl_khr_dx9_media_sharing */ +#ifdef _WIN32 + clGetDeviceIDsFromD3D11KHR_t *clGetDeviceIDsFromD3D11KHR; + clCreateFromD3D11BufferKHR_t *clCreateFromD3D11BufferKHR; + clCreateFromD3D11Texture2DKHR_t *clCreateFromD3D11Texture2DKHR; + clCreateFromD3D11Texture3DKHR_t *clCreateFromD3D11Texture3DKHR; + clCreateFromDX9MediaSurfaceKHR_t *clCreateFromDX9MediaSurfaceKHR; + clEnqueueAcquireD3D11ObjectsKHR_t *clEnqueueAcquireD3D11ObjectsKHR; + clEnqueueReleaseD3D11ObjectsKHR_t *clEnqueueReleaseD3D11ObjectsKHR; + clGetDeviceIDsFromDX9MediaAdapterKHR_t * clGetDeviceIDsFromDX9MediaAdapterKHR; - cl_api_clEnqueueAcquireDX9MediaSurfacesKHR + clEnqueueAcquireDX9MediaSurfacesKHR_t * clEnqueueAcquireDX9MediaSurfacesKHR; - cl_api_clEnqueueReleaseDX9MediaSurfacesKHR + clEnqueueReleaseDX9MediaSurfacesKHR_t * clEnqueueReleaseDX9MediaSurfacesKHR; +#else + void *clGetDeviceIDsFromD3D11KHR; + void *clCreateFromD3D11BufferKHR; + void *clCreateFromD3D11Texture2DKHR; + void *clCreateFromD3D11Texture3DKHR; + void *clCreateFromDX9MediaSurfaceKHR; + void *clEnqueueAcquireD3D11ObjectsKHR; + void *clEnqueueReleaseD3D11ObjectsKHR; + void *clGetDeviceIDsFromDX9MediaAdapterKHR; + void *clEnqueueAcquireDX9MediaSurfacesKHR; + void *clEnqueueReleaseDX9MediaSurfacesKHR; +#endif /* cl_khr_egl_image */ - cl_api_clCreateFromEGLImageKHR clCreateFromEGLImageKHR; - cl_api_clEnqueueAcquireEGLObjectsKHR clEnqueueAcquireEGLObjectsKHR; - cl_api_clEnqueueReleaseEGLObjectsKHR clEnqueueReleaseEGLObjectsKHR; + clCreateFromEGLImageKHR_t *clCreateFromEGLImageKHR; + clEnqueueAcquireEGLObjectsKHR_t *clEnqueueAcquireEGLObjectsKHR; + clEnqueueReleaseEGLObjectsKHR_t *clEnqueueReleaseEGLObjectsKHR; /* cl_khr_egl_event */ - cl_api_clCreateEventFromEGLSyncKHR clCreateEventFromEGLSyncKHR; + clCreateEventFromEGLSyncKHR_t *clCreateEventFromEGLSyncKHR; /* OpenCL 2.0 */ - cl_api_clCreateCommandQueueWithProperties clCreateCommandQueueWithProperties; - cl_api_clCreatePipe clCreatePipe; - cl_api_clGetPipeInfo clGetPipeInfo; - cl_api_clSVMAlloc clSVMAlloc; - cl_api_clSVMFree clSVMFree; - cl_api_clEnqueueSVMFree clEnqueueSVMFree; - cl_api_clEnqueueSVMMemcpy clEnqueueSVMMemcpy; - cl_api_clEnqueueSVMMemFill clEnqueueSVMMemFill; - cl_api_clEnqueueSVMMap clEnqueueSVMMap; - cl_api_clEnqueueSVMUnmap clEnqueueSVMUnmap; - cl_api_clCreateSamplerWithProperties clCreateSamplerWithProperties; - cl_api_clSetKernelArgSVMPointer clSetKernelArgSVMPointer; - cl_api_clSetKernelExecInfo clSetKernelExecInfo; +#ifdef CL_VERSION_2_0 + clCreateCommandQueueWithProperties_t *clCreateCommandQueueWithProperties; + clCreatePipe_t *clCreatePipe; + clGetPipeInfo_t *clGetPipeInfo; + clSVMAlloc_t *clSVMAlloc; + clSVMFree_t *clSVMFree; + clEnqueueSVMFree_t *clEnqueueSVMFree; + clEnqueueSVMMemcpy_t *clEnqueueSVMMemcpy; + clEnqueueSVMMemFill_t *clEnqueueSVMMemFill; + clEnqueueSVMMap_t *clEnqueueSVMMap; + clEnqueueSVMUnmap_t *clEnqueueSVMUnmap; + clCreateSamplerWithProperties_t *clCreateSamplerWithProperties; + clSetKernelArgSVMPointer_t *clSetKernelArgSVMPointer; + clSetKernelExecInfo_t *clSetKernelExecInfo; +#else + void *clCreateCommandQueueWithProperties; + void *clCreatePipe; + void *clGetPipeInfo; + void *clSVMAlloc; + void *clSVMFree; + void *clEnqueueSVMFree; + void *clEnqueueSVMMemcpy; + void *clEnqueueSVMMemFill; + void *clEnqueueSVMMap; + void *clEnqueueSVMUnmap; + void *clCreateSamplerWithProperties; + void *clSetKernelArgSVMPointer; + void *clSetKernelExecInfo; +#endif /* cl_khr_sub_groups */ - cl_api_clGetKernelSubGroupInfoKHR clGetKernelSubGroupInfoKHR; + clGetKernelSubGroupInfoKHR_t *clGetKernelSubGroupInfoKHR; /* OpenCL 2.1 */ - cl_api_clCloneKernel clCloneKernel; - cl_api_clCreateProgramWithIL clCreateProgramWithIL; - cl_api_clEnqueueSVMMigrateMem clEnqueueSVMMigrateMem; - cl_api_clGetDeviceAndHostTimer clGetDeviceAndHostTimer; - cl_api_clGetHostTimer clGetHostTimer; - cl_api_clGetKernelSubGroupInfo clGetKernelSubGroupInfo; - cl_api_clSetDefaultDeviceCommandQueue clSetDefaultDeviceCommandQueue; +#ifdef CL_VERSION_2_1 + clCloneKernel_t *clCloneKernel; + clCreateProgramWithIL_t *clCreateProgramWithIL; + clEnqueueSVMMigrateMem_t *clEnqueueSVMMigrateMem; + clGetDeviceAndHostTimer_t *clGetDeviceAndHostTimer; + clGetHostTimer_t *clGetHostTimer; + clGetKernelSubGroupInfo_t *clGetKernelSubGroupInfo; + clSetDefaultDeviceCommandQueue_t *clSetDefaultDeviceCommandQueue; +#else + void *clCloneKernel; + void *clCreateProgramWithIL; + void *clEnqueueSVMMigrateMem; + void *clGetDeviceAndHostTimer; + void *clGetHostTimer; + void *clGetKernelSubGroupInfo; + void *clSetDefaultDeviceCommandQueue; +#endif /* OpenCL 2.2 */ - cl_api_clSetProgramReleaseCallback clSetProgramReleaseCallback; - cl_api_clSetProgramSpecializationConstant clSetProgramSpecializationConstant; +#ifdef CL_VERSION_2_2 + clSetProgramReleaseCallback_t *clSetProgramReleaseCallback; + clSetProgramSpecializationConstant_t *clSetProgramSpecializationConstant; +#else + void *clSetProgramReleaseCallback; + void *clSetProgramSpecializationConstant; +#endif /* OpenCL 3.0 */ - cl_api_clCreateBufferWithProperties clCreateBufferWithProperties; - cl_api_clCreateImageWithProperties clCreateImageWithProperties; - cl_api_clSetContextDestructorCallback clSetContextDestructorCallback; +#ifdef CL_VERSION_3_0 + clCreateBufferWithProperties_t *clCreateBufferWithProperties; + clCreateImageWithProperties_t *clCreateImageWithProperties; + clSetContextDestructorCallback_t *clSetContextDestructorCallback; +#else + void *clCreateBufferWithProperties; + void *clCreateImageWithProperties; + void *clSetContextDestructorCallback; +#endif } cl_icd_dispatch; diff --git a/deps/opencl-headers/CL/cl_layer.h b/deps/opencl-headers/CL/cl_layer.h index 59dae7506..245f7b532 100644 --- a/deps/opencl-headers/CL/cl_layer.h +++ b/deps/opencl-headers/CL/cl_layer.h @@ -1,61 +1,125 @@ -/* - * Copyright (c) 2020 The Khronos Group Inc. +/******************************************************************************* + * Copyright (c) 2008-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 + * 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. - * - * OpenCL is a trademark of Apple Inc. used under license by Khronos. - */ + ******************************************************************************/ -#ifndef OPENCL_CL_LAYER_H -#define OPENCL_CL_LAYER_H +#ifndef OPENCL_CL_LAYER_H_ +#define OPENCL_CL_LAYER_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ #include +#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif + #ifdef __cplusplus extern "C" { #endif -typedef cl_uint cl_layer_info; -typedef cl_uint cl_layer_api_version; -#define CL_LAYER_API_VERSION 0x4240 -#define CL_LAYER_API_VERSION_100 100 +/*************************************************************** +* cl_loader_layers +***************************************************************/ +#define cl_loader_layers 1 +#define CL_LOADER_LAYERS_EXTENSION_NAME \ + "cl_loader_layers" -extern CL_API_ENTRY cl_int CL_API_CALL -clGetLayerInfo(cl_layer_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret); -typedef cl_int -(CL_API_CALL *pfn_clGetLayerInfo)(cl_layer_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret); +#define CL_LOADER_LAYERS_EXTENSION_VERSION CL_MAKE_VERSION(1, 0, 0) + +typedef cl_uint cl_layer_info; +typedef cl_uint cl_layer_api_version; + +/* cl_layer_info */ +#define CL_LAYER_API_VERSION 0x4240 +#define CL_LAYER_NAME 0x4241 + +/* Misc API enums */ +#define CL_LAYER_API_VERSION_100 100 + + +typedef cl_int CL_API_CALL +clGetLayerInfo_t( + cl_layer_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret); + +typedef clGetLayerInfo_t * +clGetLayerInfo_fn ; + +typedef cl_int CL_API_CALL +clInitLayer_t( + cl_uint num_entries, + const cl_icd_dispatch* target_dispatch, + cl_uint* num_entries_ret, + const cl_icd_dispatch** layer_dispatch_ret); + +typedef clInitLayer_t * +clInitLayer_fn ; + +/* +** The function pointer typedefs prefixed with "pfn_" are provided for +** compatibility with earlier versions of the headers. New code is +** encouraged to use the function pointer typedefs that are suffixed with +** "_fn" instead, for consistency. +*/ + +typedef clGetLayerInfo_t * +pfn_clGetLayerInfo ; + +typedef clInitLayer_t * +pfn_clInitLayer ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetLayerInfo( + cl_layer_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) ; extern CL_API_ENTRY cl_int CL_API_CALL -clInitLayer(cl_uint num_entries, - const cl_icd_dispatch *target_dispatch, - cl_uint *num_entries_ret, - const cl_icd_dispatch **layer_dispatch_ret); +clInitLayer( + cl_uint num_entries, + const cl_icd_dispatch* target_dispatch, + cl_uint* num_entries_ret, + const cl_icd_dispatch** layer_dispatch_ret) ; -typedef cl_int -(CL_API_CALL *pfn_clInitLayer)(cl_uint num_entries, - const cl_icd_dispatch *target_dispatch, - cl_uint *num_entries_ret, - const cl_icd_dispatch **layer_dispatch_ret); +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif -#endif /* OPENCL_CL_LAYER_H */ +#endif /* OPENCL_CL_LAYER_H_ */ diff --git a/deps/opencl-headers/CL/cl_platform.h b/deps/opencl-headers/CL/cl_platform.h index 4f6444e62..5f92d6faa 100644 --- a/deps/opencl-headers/CL/cl_platform.h +++ b/deps/opencl-headers/CL/cl_platform.h @@ -77,7 +77,7 @@ extern "C" { #ifdef __GNUC__ #define CL_API_SUFFIX_DEPRECATED __attribute__((deprecated)) #define CL_API_PREFIX_DEPRECATED -#elif defined(_WIN32) +#elif defined(_MSC_VER) && !defined(__clang__) #define CL_API_SUFFIX_DEPRECATED #define CL_API_PREFIX_DEPRECATED __declspec(deprecated) #else @@ -361,11 +361,6 @@ typedef double cl_double; #include -/* Mirror types to GL types. Mirror types allow us to avoid deciding which 87s to load based on whether we are using GL or GLES here. */ -typedef unsigned int cl_GLuint; -typedef int cl_GLint; -typedef unsigned int cl_GLenum; - /* * Vector types * @@ -516,6 +511,9 @@ typedef unsigned int cl_GLenum; #elif defined(__GNUC__) && ! defined(__STRICT_ANSI__) #define __CL_HAS_ANON_STRUCT__ 1 #define __CL_ANON_STRUCT__ __extension__ +#elif defined(__clang__) +#define __CL_HAS_ANON_STRUCT__ 1 +#define __CL_ANON_STRUCT__ __extension__ #else #define __CL_HAS_ANON_STRUCT__ 0 #define __CL_ANON_STRUCT__ diff --git a/deps/opencl-headers/CL/cl_va_api_media_sharing_intel.h b/deps/opencl-headers/CL/cl_va_api_media_sharing_intel.h index 547e90e88..9fb8863f2 100644 --- a/deps/opencl-headers/CL/cl_va_api_media_sharing_intel.h +++ b/deps/opencl-headers/CL/cl_va_api_media_sharing_intel.h @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2008-2020 The Khronos Group Inc. + * Copyright (c) 2008-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. @@ -14,13 +14,34 @@ * limitations under the License. ******************************************************************************/ -#ifndef __OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H -#define __OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H +#ifndef OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ +#define OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ -#include -#include #include +#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && \ + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif + #ifdef __cplusplus extern "C" { #endif @@ -29,21 +50,31 @@ extern "C" { * cl_intel_sharing_format_query_va_api ***************************************************************/ #define cl_intel_sharing_format_query_va_api 1 +#define CL_INTEL_SHARING_FORMAT_QUERY_VA_API_EXTENSION_NAME \ + "cl_intel_sharing_format_query_va_api" + + +#define CL_INTEL_SHARING_FORMAT_QUERY_VA_API_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) /* when cl_intel_va_api_media_sharing is supported */ -extern CL_API_ENTRY cl_int CL_API_CALL -clGetSupportedVA_APIMediaSurfaceFormatsINTEL( +typedef cl_int CL_API_CALL +clGetSupportedVA_APIMediaSurfaceFormatsINTEL_t( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint plane, cl_uint num_entries, VAImageFormat* va_api_formats, - cl_uint* num_surface_formats) ; + cl_uint* num_surface_formats); -typedef cl_int (CL_API_CALL * -clGetSupportedVA_APIMediaSurfaceFormatsINTEL_fn)( +typedef clGetSupportedVA_APIMediaSurfaceFormatsINTEL_t * +clGetSupportedVA_APIMediaSurfaceFormatsINTEL_fn ; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) + +extern CL_API_ENTRY cl_int CL_API_CALL +clGetSupportedVA_APIMediaSurfaceFormatsINTEL( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -52,13 +83,22 @@ clGetSupportedVA_APIMediaSurfaceFormatsINTEL_fn)( VAImageFormat* va_api_formats, cl_uint* num_surface_formats) ; -/****************************************** -* cl_intel_va_api_media_sharing extension * -*******************************************/ +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ +/*************************************************************** +* cl_intel_va_api_media_sharing +***************************************************************/ #define cl_intel_va_api_media_sharing 1 +#define CL_INTEL_VA_API_MEDIA_SHARING_EXTENSION_NAME \ + "cl_intel_va_api_media_sharing" + + +#define CL_INTEL_VA_API_MEDIA_SHARING_EXTENSION_VERSION CL_MAKE_VERSION(0, 0, 0) -/* error codes */ +typedef cl_uint cl_va_api_device_source_intel; +typedef cl_uint cl_va_api_device_set_intel; + +/* Error codes */ #define CL_INVALID_VA_API_MEDIA_ADAPTER_INTEL -1098 #define CL_INVALID_VA_API_MEDIA_SURFACE_INTEL -1099 #define CL_VA_API_MEDIA_SURFACE_ALREADY_ACQUIRED_INTEL -1100 @@ -84,80 +124,97 @@ clGetSupportedVA_APIMediaSurfaceFormatsINTEL_fn)( #define CL_COMMAND_ACQUIRE_VA_API_MEDIA_SURFACES_INTEL 0x409A #define CL_COMMAND_RELEASE_VA_API_MEDIA_SURFACES_INTEL 0x409B -typedef cl_uint cl_va_api_device_source_intel; -typedef cl_uint cl_va_api_device_set_intel; + +typedef cl_int CL_API_CALL +clGetDeviceIDsFromVA_APIMediaAdapterINTEL_t( + cl_platform_id platform, + cl_va_api_device_source_intel media_adapter_type, + void* media_adapter, + cl_va_api_device_set_intel media_adapter_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices); + +typedef clGetDeviceIDsFromVA_APIMediaAdapterINTEL_t * +clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_mem CL_API_CALL +clCreateFromVA_APIMediaSurfaceINTEL_t( + cl_context context, + cl_mem_flags flags, + VASurfaceID* surface, + cl_uint plane, + cl_int* errcode_ret); + +typedef clCreateFromVA_APIMediaSurfaceINTEL_t * +clCreateFromVA_APIMediaSurfaceINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueAcquireVA_APIMediaSurfacesINTEL_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueAcquireVA_APIMediaSurfacesINTEL_t * +clEnqueueAcquireVA_APIMediaSurfacesINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +typedef cl_int CL_API_CALL +clEnqueueReleaseVA_APIMediaSurfacesINTEL_t( + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event); + +typedef clEnqueueReleaseVA_APIMediaSurfacesINTEL_t * +clEnqueueReleaseVA_APIMediaSurfacesINTEL_fn CL_API_SUFFIX__VERSION_1_2; + +#if !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) extern CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromVA_APIMediaAdapterINTEL( - cl_platform_id platform, - cl_va_api_device_source_intel media_adapter_type, - void* media_adapter, - cl_va_api_device_set_intel media_adapter_set, - cl_uint num_entries, - cl_device_id* devices, - cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL * clGetDeviceIDsFromVA_APIMediaAdapterINTEL_fn)( - cl_platform_id platform, + cl_platform_id platform, cl_va_api_device_source_intel media_adapter_type, - void* media_adapter, - cl_va_api_device_set_intel media_adapter_set, - cl_uint num_entries, - cl_device_id* devices, - cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; + void* media_adapter, + cl_va_api_device_set_intel media_adapter_set, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_mem CL_API_CALL clCreateFromVA_APIMediaSurfaceINTEL( - cl_context context, - cl_mem_flags flags, - VASurfaceID* surface, - cl_uint plane, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_mem (CL_API_CALL * clCreateFromVA_APIMediaSurfaceINTEL_fn)( - cl_context context, - cl_mem_flags flags, - VASurfaceID* surface, - cl_uint plane, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; + cl_context context, + cl_mem_flags flags, + VASurfaceID* surface, + cl_uint plane, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireVA_APIMediaSurfacesINTEL( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL *clEnqueueAcquireVA_APIMediaSurfacesINTEL_fn)( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; extern CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseVA_APIMediaSurfacesINTEL( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; - -typedef cl_int (CL_API_CALL *clEnqueueReleaseVA_APIMediaSurfacesINTEL_fn)( - cl_command_queue command_queue, - cl_uint num_objects, - const cl_mem* mem_objects, - cl_uint num_events_in_wait_list, - const cl_event* event_wait_list, - cl_event* event) CL_API_SUFFIX__VERSION_1_2; + cl_command_queue command_queue, + cl_uint num_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) CL_API_SUFFIX__VERSION_1_2; + +#endif /* !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) */ #ifdef __cplusplus } #endif -#endif /* __OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H */ - +#endif /* OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_ */ diff --git a/deps/opencl-headers/CMakeLists.txt b/deps/opencl-headers/CMakeLists.txt index e6ea8b5e5..1b207749e 100644 --- a/deps/opencl-headers/CMakeLists.txt +++ b/deps/opencl-headers/CMakeLists.txt @@ -1,5 +1,4 @@ -cmake_minimum_required(VERSION 3.0) -cmake_policy(VERSION 3.0...3.22) +cmake_minimum_required(VERSION 3.16...3.26) # Include guard for including this project multiple times if(TARGET Headers) @@ -7,7 +6,7 @@ if(TARGET Headers) endif() project(OpenCLHeaders - VERSION 2.2 + VERSION 3.0 LANGUAGES C # Ideally should be NONE, but GNUInstallDirs detects platform arch using try_compile # https://stackoverflow.com/questions/43379311/why-does-project-affect-cmakes-opinion-on-cmake-sizeof-void-p ) @@ -15,15 +14,18 @@ project(OpenCLHeaders option(OPENCL_HEADERS_BUILD_TESTING "Enable support for OpenCL C headers testing." OFF) option(OPENCL_HEADERS_BUILD_CXX_TESTS "Enable support for OpenCL C headers testing in C++ mode." ON) +set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") include(GNUInstallDirs) +include(JoinPaths) +include(Package) add_library(Headers INTERFACE) add_library(OpenCL::Headers ALIAS Headers) if(CMAKE_SYSTEM_NAME MATCHES Darwin) execute_process( - COMMAND ln -shf ${CMAKE_CURRENT_SOURCE_DIR}/CL ${CMAKE_CURRENT_BINARY_DIR}/CL - COMMAND ln -shf ${CMAKE_CURRENT_SOURCE_DIR}/CL ${CMAKE_CURRENT_BINARY_DIR}/OpenCL + COMMAND ln -snf ${CMAKE_CURRENT_SOURCE_DIR}/CL ${CMAKE_CURRENT_BINARY_DIR}/CL + COMMAND ln -snf ${CMAKE_CURRENT_SOURCE_DIR}/CL ${CMAKE_CURRENT_BINARY_DIR}/OpenCL ) target_include_directories(Headers INTERFACE @@ -31,9 +33,9 @@ if(CMAKE_SYSTEM_NAME MATCHES Darwin) $ ) install(CODE " - file(MAKE_DIRECTORY ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/CL) + file(MAKE_DIRECTORY ${CMAKE_INSTALL_FULL_INCLUDEDIR}/CL) execute_process( - COMMAND ln -shf CL ${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/OpenCL + COMMAND ln -snf CL ${CMAKE_INSTALL_FULL_INCLUDEDIR}/OpenCL )" ) else() @@ -93,3 +95,47 @@ endif() if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_HEADERS_BUILD_TESTING) AND BUILD_TESTING) add_subdirectory(tests) endif() + +if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME) + find_package(Python3 COMPONENTS Interpreter) + set(OPENCL_HEADERS_XML_PATH CACHE FILEPATH "Path to cl.xml for OpenCL Header genereration") + set(OPENCL_HEADERS_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/generated) + add_custom_target(headers_generate + COMMAND ${CMAKE_COMMAND} -E make_directory ${OPENCL_HEADERS_OUTPUT_DIRECTORY} + COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_CURRENT_SOURCE_DIR}/scripts + ${Python3_EXECUTABLE} gen_headers.py + -registry ${OPENCL_HEADERS_XML_PATH} + -o ${OPENCL_HEADERS_OUTPUT_DIRECTORY} + ) + add_custom_target(headers_copy + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_d3d10.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_d3d11.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_dx9_media_sharing.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_egl.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_ext.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_gl.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_layer.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_va_api_media_sharing_intel.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + COMMAND ${CMAKE_COMMAND} -E copy + ${OPENCL_HEADERS_OUTPUT_DIRECTORY}/cl_function_types.h + ${CMAKE_CURRENT_SOURCE_DIR}/CL + ) + set_target_properties(headers_generate PROPERTIES FOLDER "Generation") + set_target_properties(headers_copy PROPERTIES FOLDER "Generation") +endif() diff --git a/deps/opencl-headers/OpenCL-Headers.pc.in b/deps/opencl-headers/OpenCL-Headers.pc.in new file mode 100644 index 000000000..5cc13fbad --- /dev/null +++ b/deps/opencl-headers/OpenCL-Headers.pc.in @@ -0,0 +1,7 @@ +prefix=@PKGCONFIG_PREFIX@ +includedir=@OPENCL_INCLUDEDIR_PC@ + +Name: OpenCL-Headers +Description: Khronos OpenCL Headers +Version: 3.0 +Cflags: -I${includedir} diff --git a/deps/opencl-headers/README.md b/deps/opencl-headers/README.md index 6b104cddf..93756c814 100644 --- a/deps/opencl-headers/README.md +++ b/deps/opencl-headers/README.md @@ -70,6 +70,51 @@ include the OpenCL API headers as follows: #include ``` +## Controlling Function Prototypes + +By default, the OpenCL API headers in this repository declare function +prototypes for every known core OpenCL API and OpenCL extension API. If this is +not desired, the declared function prototypes can be controlled by the following +preprocessor defines: + +* `CL_NO_PROTOTYPES`: No function prototypes will be declared. This control + applies to core OpenCL APIs and OpenCL extension APIs. +* `CL_NO_CORE_PROTOTYPES`: No function prototypes will be declared for core + OpenCL APIs. +* `CL_NO_EXTENSION_PROTOTYPES`: No function prototypes will be declared for + OpenCL extension APIs. This control applies to all OpenCL extension APIs. +* `CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES`: No function prototypes will be + declared for OpenCL extension APIs that are in the ICD dispatch table for + historical reasons. +* `CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES`: No function prototypes will be + declared for OpenCL extension APIs that are not in the ICD dispatch table. + +For example, to declare function prototypes for core OpenCL 3.0 APIs only, you +may include the OpenCL API headers as follows: + +```c +#define CL_TARGET_OPENCL_VERSION 300 +#define CL_NO_EXTENSION_PROTOTYPES +#include +``` + +## Compatibility Notes + +OpenCL values backward compatibility and in most cases an application using an +older version of the OpenCL API headers can seamlessly update to a newer version +of the OpenCL API headers. In rare cases, though, the OpenCL API headers may +break backward compatibility: + +* Very rarely, there may be bugs or other issues in the OpenCL API headers that + cannot be fixed without breaking compatibility. +* The OpenCL API headers for provisional features or provisional extensions may + be changed in a way that breaks compatibility. + +Applications or libraries that require stable OpenCL API headers are encouraged +to use tagged or released OpenCL API headers. We will do our best to document +any breaking changes in the description of each release. The OpenCL API headers +are tagged at least as often as each OpenCL specification release. + ## Directory Structure ``` @@ -78,6 +123,11 @@ LICENSE Source license for the OpenCL API headers CL/ Unified OpenCL API headers tree ``` +## Packaging + +For packaging instructions, see [RELEASE.md](https://github.com/KhronosGroup/OpenCL-SDK/blob/main/docs/RELEASE.md) +in the OpenCL SDK repository. + ## License See [LICENSE](LICENSE). diff --git a/deps/opencl-headers/cmake/DebSourcePkg.cmake b/deps/opencl-headers/cmake/DebSourcePkg.cmake new file mode 100644 index 000000000..9199a8cd3 --- /dev/null +++ b/deps/opencl-headers/cmake/DebSourcePkg.cmake @@ -0,0 +1,125 @@ +# This script produces the changelog, control and rules file in the debian +# directory. These files are needed to build a Debian source package from the repository. +# Run this in CMake script mode, e.g. +# $ cd OpenCL-Headers +# $ cmake -S . -B ../build -D BUILD_TESTING=OFF +# $ cmake +# -DCMAKE_CACHE_PATH=../build/CMakeCache.txt +# -DCPACK_DEBIAN_PACKAGE_MAINTAINER="Example Name " +# -DDEBIAN_DISTROSERIES=jammy +# -DORIG_ARCHIVE=../OpenCL-Headers.tar.gz +# -DLATEST_RELEASE_VERSION=v2023.08.29 +# -P cmake/DebSourcePkg.cmake +# $ debuild -S -sa + +cmake_minimum_required(VERSION 3.21) # file(COPY_FILE) is added in CMake 3.21 + +set(DEB_SOURCE_PKG_NAME "khronos-opencl-headers") +set(DEB_CLHPP_PKG_NAME "opencl-clhpp-headers") +set(DEB_META_PKG_NAME "opencl-headers") +set(DEB_META_PKG_DESCRIPTION "OpenCL (Open Computing Language) header files + OpenCL (Open Computing Language) is a multi-vendor open standard for + general-purpose parallel programming of heterogeneous systems that include + CPUs, GPUs and other processors. + . + This metapackage depends on packages providing the C and C++ headers files + for the OpenCL API as published by The Khronos Group Inc. The corresponding + specification and documentation can be found on the Khronos website.") + +if(NOT EXISTS "${CMAKE_CACHE_PATH}") + message(FATAL_ERROR "CMAKE_CACHE_PATH is not set or does not exist") +endif() +if(NOT DEFINED DEBIAN_PACKAGE_MAINTAINER) + message(FATAL_ERROR "DEBIAN_PACKAGE_MAINTAINER is not set") +endif() +if(NOT DEFINED DEBIAN_DISTROSERIES) + message(FATAL_ERROR "DEBIAN_DISTROSERIES is not set") +endif() +if(NOT DEFINED ORIG_ARCHIVE) + message(WARNING "ORIG_ARCHIVE is not set") +elseif(NOT EXISTS "${ORIG_ARCHIVE}") + message(FATAL_ERROR "ORIG_ARCHIVE is defined, but the file does not exist at \"${ORIG_ARCHIVE}\"") +endif() +if(NOT DEFINED LATEST_RELEASE_VERSION) + message(WARNING "LATEST_RELEASE_VERSION is not set") +endif() +if(NOT DEFINED DEBIAN_VERSION_SUFFIX) + message(WARNING "DEBIAN_VERSION_SUFFIX is not set") +endif() + +# Extracting the project version from the main CMakeLists.txt via regex +file(READ "${CMAKE_CACHE_PATH}" CMAKE_CACHE) +string(REGEX MATCH "CMAKE_PROJECT_VERSION[^=]*=([^\n]*)" REGEX_MATCH "${CMAKE_CACHE}") +if(NOT REGEX_MATCH) + message(FATAL_ERROR "Could not extract project version from CMakeLists.txt") +endif() +set(PROJECT_VERSION "${CMAKE_MATCH_1}") + +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}") +# Package.cmake contains all details for packaging +include(PackageSetup) + +# Append a space after every newline in the description. This format is required +# in the control file. +string(REPLACE "\n" "\n " CPACK_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}") + +set(DEB_SOURCE_PKG_DIR "${CMAKE_CURRENT_LIST_DIR}/../debian") +# Write debian/control +file(WRITE "${DEB_SOURCE_PKG_DIR}/control" +"Source: ${DEB_SOURCE_PKG_NAME} +Section: ${CPACK_DEBIAN_PACKAGE_SECTION} +Priority: optional +Maintainer: ${DEBIAN_PACKAGE_MAINTAINER} +Build-Depends: cmake, debhelper-compat (=13) +Rules-Requires-Root: no +Homepage: ${CPACK_DEBIAN_PACKAGE_HOMEPAGE} +Standards-Version: 4.6.2 + +Package: ${DEBIAN_PACKAGE_NAME} +Architecture: ${CPACK_DEBIAN_PACKAGE_ARCHITECTURE} +Multi-Arch: foreign +Breaks: ${CPACK_DEBIAN_PACKAGE_BREAKS} +Replaces: ${CPACK_DEBIAN_PACKAGE_REPLACES} +Description: ${CPACK_PACKAGE_DESCRIPTION} + +Package: ${DEB_META_PKG_NAME} +Architecture: ${CPACK_DEBIAN_PACKAGE_ARCHITECTURE} +Multi-Arch: foreign +Depends: ${DEBIAN_PACKAGE_NAME} (= ${PACKAGE_VERSION_REVISION}), ${DEB_CLHPP_PKG_NAME} (= ${PACKAGE_VERSION_REVISION}) +Description: ${DEB_META_PKG_DESCRIPTION} +" +) +# Write debian/changelog +string(TIMESTAMP CURRENT_TIMESTAMP "%a, %d %b %Y %H:%M:%S +0000" UTC) +file(WRITE "${DEB_SOURCE_PKG_DIR}/changelog" +"${DEB_SOURCE_PKG_NAME} (${PACKAGE_VERSION_REVISION}) ${DEBIAN_DISTROSERIES}; urgency=medium + + * Released version ${PACKAGE_VERSION_REVISION} + + -- ${DEBIAN_PACKAGE_MAINTAINER} ${CURRENT_TIMESTAMP} +") +# Write debian/rules +file(WRITE "${DEB_SOURCE_PKG_DIR}/rules" +"#!/usr/bin/make -f +%: +\tdh $@ + +override_dh_auto_configure: +\tdh_auto_configure -- -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF + +override_dh_auto_install: +\tdh_auto_install --destdir=debian/${DEBIAN_PACKAGE_NAME}/ +") + +if(DEFINED ORIG_ARCHIVE) + # Copy the passed orig.tar.gz file. The target filename is deduced from the version number, as expected by debuild + cmake_path(IS_ABSOLUTE ORIG_ARCHIVE IS_ORIG_ARCHIVE_ABSOLUTE) + if (NOT IS_ORIG_ARCHIVE_ABSOLUTE) + message(FATAL_ERROR "ORIG_ARCHIVE must be an absolute path (passed: \"${ORIG_ARCHIVE}\")") + endif() + cmake_path(GET ORIG_ARCHIVE EXTENSION ORIG_ARCHIVE_EXT) + cmake_path(GET ORIG_ARCHIVE PARENT_PATH ORIG_ARCHIVE_PARENT) + set(TARGET_PATH "${ORIG_ARCHIVE_PARENT}/${DEB_SOURCE_PKG_NAME}_${CPACK_DEBIAN_PACKAGE_VERSION}${ORIG_ARCHIVE_EXT}") + message(STATUS "Copying \"${ORIG_ARCHIVE}\" to \"${TARGET_PATH}\"") + file(COPY_FILE "${ORIG_ARCHIVE}" "${TARGET_PATH}") +endif() diff --git a/deps/opencl-headers/cmake/JoinPaths.cmake b/deps/opencl-headers/cmake/JoinPaths.cmake new file mode 100644 index 000000000..32d6d6685 --- /dev/null +++ b/deps/opencl-headers/cmake/JoinPaths.cmake @@ -0,0 +1,26 @@ +# This module provides function for joining paths +# known from from most languages +# +# Original license: +# SPDX-License-Identifier: (MIT OR CC0-1.0) +# Explicit permission given to distribute this module under +# the terms of the project as described in /LICENSE.rst. +# Copyright 2020 Jan Tojnar +# https://github.com/jtojnar/cmake-snips +# +# Modelled after Python’s os.path.join +# https://docs.python.org/3.7/library/os.path.html#os.path.join +# Windows not supported +function(join_paths joined_path first_path_segment) + set(temp_path "${first_path_segment}") + foreach(current_segment IN LISTS ARGN) + if(NOT ("${current_segment}" STREQUAL "")) + if(IS_ABSOLUTE "${current_segment}") + set(temp_path "${current_segment}") + else() + set(temp_path "${temp_path}/${current_segment}") + endif() + endif() + endforeach() + set(${joined_path} "${temp_path}" PARENT_SCOPE) +endfunction() diff --git a/deps/opencl-headers/cmake/Package.cmake b/deps/opencl-headers/cmake/Package.cmake new file mode 100644 index 000000000..6e207c1dd --- /dev/null +++ b/deps/opencl-headers/cmake/Package.cmake @@ -0,0 +1,47 @@ +include("${CMAKE_CURRENT_LIST_DIR}/PackageSetup.cmake") + +# Configuring pkgconfig + +# We need two different instances of OpenCL-Headers.pc +# One for installing (cmake --install), which contains CMAKE_INSTALL_PREFIX as prefix +# And another for the Debian package, which contains CPACK_PACKAGING_INSTALL_PREFIX as prefix + +join_paths(OPENCL_INCLUDEDIR_PC "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + +set(pkg_config_location ${CMAKE_INSTALL_DATADIR}/pkgconfig) +set(PKGCONFIG_PREFIX "${CMAKE_INSTALL_PREFIX}") +configure_file( + OpenCL-Headers.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL-Headers.pc + @ONLY) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL-Headers.pc + DESTINATION ${pkg_config_location} + COMPONENT pkgconfig_install) + +set(PKGCONFIG_PREFIX "${CPACK_PACKAGING_INSTALL_PREFIX}") +configure_file( + OpenCL-Headers.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL-Headers.pc + @ONLY) +# This install component is only needed in the Debian package +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL-Headers.pc + DESTINATION ${pkg_config_location} + COMPONENT pkgconfig_package + EXCLUDE_FROM_ALL) + +# By using component based packaging, component pkgconfig_install +# can be excluded from the package, and component pkgconfig_package +# can be included. +set(CPACK_DEB_COMPONENT_INSTALL ON) +set(CPACK_COMPONENTS_GROUPING "ALL_COMPONENTS_IN_ONE") + +include(CPackComponent) +cpack_add_component(pkgconfig_install) +cpack_add_component(pkgconfig_package) +set(CPACK_COMPONENTS_ALL "Unspecified;pkgconfig_package") + +set(CPACK_DEBIAN_PACKAGE_DEBUG ON) + +include(CPack) diff --git a/deps/opencl-headers/cmake/PackageSetup.cmake b/deps/opencl-headers/cmake/PackageSetup.cmake new file mode 100644 index 000000000..92075a0cf --- /dev/null +++ b/deps/opencl-headers/cmake/PackageSetup.cmake @@ -0,0 +1,56 @@ +set(CPACK_PACKAGE_VENDOR "khronos") + +set(CPACK_PACKAGE_DESCRIPTION "OpenCL (Open Computing Language) C header files +OpenCL (Open Computing Language) is a multi-vendor open standard for +general-purpose parallel programming of heterogeneous systems that include +CPUs, GPUs and other processors. +. +This package provides the C development header files for the OpenCL API +as published by The Khronos Group Inc. The corresponding specification and +documentation can be found on the Khronos website.") + +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") + +set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md") + +if(NOT CPACK_PACKAGING_INSTALL_PREFIX) + set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") +endif() + +# DEB packaging configuration +if(NOT DEFINED CPACK_DEBIAN_PACKAGE_MAINTAINER) + set(CPACK_DEBIAN_PACKAGE_MAINTAINER ${CPACK_PACKAGE_VENDOR}) +endif() + +set(CPACK_DEBIAN_PACKAGE_HOMEPAGE + "https://github.com/KhronosGroup/OpenCL-Headers") + +# Version number [epoch:]upstream_version[-debian_revision] +set(CPACK_DEBIAN_PACKAGE_VERSION "${PROJECT_VERSION}") # upstream_version +if(DEFINED LATEST_RELEASE_VERSION) + # Remove leading "v", if exists + string(LENGTH "${LATEST_RELEASE_VERSION}" LATEST_RELEASE_VERSION_LENGTH) + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 0 1 LATEST_RELEASE_VERSION_FRONT) + if(LATEST_RELEASE_VERSION_FRONT STREQUAL "v") + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 1 ${LATEST_RELEASE_VERSION_LENGTH} LATEST_RELEASE_VERSION) + endif() + + string(APPEND CPACK_DEBIAN_PACKAGE_VERSION "~${LATEST_RELEASE_VERSION}") +endif() +set(CPACK_DEBIAN_PACKAGE_RELEASE "1") # debian_revision (because this is a + # non-native pkg) +set(PACKAGE_VERSION_REVISION "${CPACK_DEBIAN_PACKAGE_VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}${DEBIAN_VERSION_SUFFIX}") + +set(DEBIAN_PACKAGE_NAME "opencl-c-headers") +set(CPACK_DEBIAN_PACKAGE_NAME + "${DEBIAN_PACKAGE_NAME}" + CACHE STRING "Package name" FORCE) + +set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "all") +set(CPACK_DEBIAN_PACKAGE_SECTION "libdevel") +set(CPACK_DEBIAN_PACKAGE_BREAKS "opencl-headers (<< ${CPACK_DEBIAN_PACKAGE_VERSION}), opencl-clhpp-headers (<< ${CPACK_DEBIAN_PACKAGE_VERSION})") +set(CPACK_DEBIAN_PACKAGE_REPLACES "opencl-headers (<< ${CPACK_DEBIAN_PACKAGE_VERSION})") + +# Package file name in deb format: +# _-_.deb +set(CPACK_DEBIAN_FILE_NAME "${DEBIAN_PACKAGE_NAME}_${PACKAGE_VERSION_REVISION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb") diff --git a/deps/opencl-headers/scripts/.gitignore b/deps/opencl-headers/scripts/.gitignore new file mode 100644 index 000000000..b971803c4 --- /dev/null +++ b/deps/opencl-headers/scripts/.gitignore @@ -0,0 +1 @@ +gen/__pycache__/* diff --git a/deps/opencl-headers/scripts/README.md b/deps/opencl-headers/scripts/README.md new file mode 100644 index 000000000..6597642ea --- /dev/null +++ b/deps/opencl-headers/scripts/README.md @@ -0,0 +1,38 @@ +# OpenCL Header Code Generation + +## Introduction + +In order to ease maintenance and enable faster development in the OpenCL headers, the OpenCL headers for extensions are generated from the OpenCL XML machine readable grammar. +Currently, header generation is only enabled for the OpenCL headers for extensions, and the OpenCL headers for core APIs are still authored manually. + +## Dependencies + +The OpenCL headers are generated using Python [Mako Templates](https://www.makotemplates.org/). + +In most cases, after installing Python for your platform, Mako may be installed using: + +```sh +$ pip install Mako +``` + +## Making Changes + +Most changes only require modifications to the Mako templates. +Small changes modifying syntax or layout are simple and straightforward. +Occasionally, more complicated changes will be required, say when a new API is added that is unlike any previous API or when a new extension header file is needed, but this should be rare. + +The Python script should only need to be modified if additional information needs to be propagated from the XML file into the Mako template itself. + +## Generating Headers + +The script to generate headers requires the `cl.xml` machine readable grammar. +The latest version of `cl.xml` may be found in the Khronos OpenCL-Docs repo [here](https://github.com/KhronosGroup/OpenCL-Docs/blob/main/xml/cl.xml). + +The easiest way to generate new headers is by using the `headers_generate` target. +For example, from a directory used to build the headers, simply execute: + +```sh +$ cmake --build . --target headers_generate +``` + +The `cl.xml` file used to generate headers with the header generation target may be provided by setting the CMake variable `OPENCL_HEADERS_XML_PATH` to the full path to `cl.xml`. diff --git a/deps/opencl-headers/scripts/check-format.sh b/deps/opencl-headers/scripts/check-format.sh new file mode 100755 index 000000000..24c616620 --- /dev/null +++ b/deps/opencl-headers/scripts/check-format.sh @@ -0,0 +1,55 @@ +#!/usr/bin/env bash + +SOURCE_COMMIT="$1" +if [ "$#" -gt 0 ]; then + shift +fi + +# If no source commit is given target the default branch +if [ "x$SOURCE_COMMIT" = "x" ]; then + # If remote is not set use the remote of the current branch or fallback to "origin" + if [ "x$REMOTE" = "x" ]; then + BRANCH="$(git rev-parse --abbrev-ref HEAD)" + REMOTE="$(git config --local --get "branch.$BRANCH.remote" || echo 'origin')" + fi + SOURCE_COMMIT="remotes/$REMOTE/HEAD" +fi + +# Force colored diff output +DIFF_COLOR_SAVED="$(git config --local --get color.diff)" +if [ "x$DIFF_COLOR_SAVED" != "x" ]; then + git config --local --replace-all "color.diff" "always" +else + git config --local --add "color.diff" "always" +fi + +scratch="$(mktemp -t check-format.XXXXXXXXXX)" +finish () { + # Remove temporary file + rm -rf "$scratch" + # Restore setting + if [ "x$DIFF_COLOR_SAVED" != "x" ]; then + git config --local --replace-all "color.diff" "$DIFF_COLOR_SAVED" + else + git config --local --unset "color.diff" + fi +} +# The trap will be invoked whenever the script exits, even due to a signal, this is a bash only +# feature +trap finish EXIT + +GIT_CLANG_FORMAT="${GIT_CLANG_FORMAT:-git-clang-format}" +"$GIT_CLANG_FORMAT" --style=file --extensions=cc,cp,cpp,c++,cxx,cu,cuh,hh,hpp,hxx,hip,vert,frag --diff "$@" "$SOURCE_COMMIT" > "$scratch" + +# Check for no-ops +grep '^no modified files to format$\|^clang-format did not modify any files$' \ + "$scratch" > /dev/null && exit 0 + +# Dump formatting diff and signal failure +printf \ +"\033[31m==== FORMATTING VIOLATIONS DETECTED ====\033[0m +run '\033[33m%s --style=file %s %s\033[0m' to apply these formating changes\n\n" \ +"$GIT_CLANG_FORMAT" "$*" "$SOURCE_COMMIT" + +cat "$scratch" +exit 1 diff --git a/deps/opencl-headers/scripts/cl_ext.h.mako b/deps/opencl-headers/scripts/cl_ext.h.mako new file mode 100644 index 000000000..f42bb1b1f --- /dev/null +++ b/deps/opencl-headers/scripts/cl_ext.h.mako @@ -0,0 +1,447 @@ +<% +# re.match used to parse extension semantic versions +from re import match + +# Extensions to skip by default because they are in dedicated headers: +skipExtensions = { + 'cl_khr_d3d10_sharing', + 'cl_khr_d3d11_sharing', + 'cl_khr_dx9_media_sharing', + 'cl_khr_egl_event', + 'cl_khr_egl_image', + 'cl_khr_gl_depth_images', + 'cl_khr_gl_event', + 'cl_khr_gl_msaa_sharing', + 'cl_khr_gl_sharing', + 'cl_loader_layers', + 'cl_intel_dx9_media_sharing', + 'cl_intel_va_api_media_sharing', + 'cl_intel_sharing_format_query_d3d10', + 'cl_intel_sharing_format_query_d3d11', + 'cl_intel_sharing_format_query_dx9', + 'cl_intel_sharing_format_query_gl', + 'cl_intel_sharing_format_query_va_api', + } + +# Extensions to include in this header: +def shouldGenerate(extension): + if extension in genExtensions: + return True + elif not genExtensions and not extension in skipExtensions: + return True + return False + +# XML blocks to include in the headers: +def shouldEmit(block): + for type in block.findall('type'): + if type.get('name') in typedefs: + return True + elif type.get('name') in macros: + return True + elif type.get('name') in structs: + return True + for enum in block.findall('enum'): + #if enum.get('name') in enums: + return True + for func in block.findall('command'): + return True + return False + +# Initially, keep the same extension order as the original headers: +orderedExtensions = [ + # cl_ext.h: + 'cl_khr_command_buffer', + 'cl_khr_command_buffer_multi_device', + 'cl_khr_command_buffer_mutable_dispatch', + 'cl_khr_fp64', + 'cl_khr_fp16', + 'cl_APPLE_SetMemObjectDestructor', + 'cl_APPLE_ContextLoggingFunctions', + 'cl_khr_icd', + 'cl_khr_il_program', + 'cl_khr_image2D_from_buffer', # incorrect name + 'cl_khr_image2d_from_buffer', + 'cl_khr_initialize_memory', + 'cl_khr_terminate_context', + 'cl_khr_spir', + 'cl_khr_create_command_queue', + 'cl_nv_device_attribute_query', + 'cl_amd_device_attribute_query', + 'cl_arm_printf', + 'cl_ext_device_fission', + 'cl_ext_migrate_memobject', + 'cl_ext_cxx_for_opencl', + 'cl_qcom_ext_host_ptr', + 'cl_qcom_ext_host_ptr_iocoherent', + 'cl_qcom_ion_host_ptr', + 'cl_qcom_android_native_buffer_host_ptr', + 'cl_img_yuv_image', + 'cl_img_cached_allocations', + 'cl_img_use_gralloc_ptr', + 'cl_img_generate_mipmap', + 'cl_img_mem_properties', + 'cl_khr_subgroups', + 'cl_khr_mipmap_image', + 'cl_khr_priority_hints', + 'cl_khr_throttle_hints', + 'cl_khr_subgroup_named_barrier', + 'cl_khr_extended_versioning', + 'cl_khr_device_uuid', + 'cl_khr_pci_bus_info', + 'cl_khr_suggested_local_work_size', + 'cl_khr_integer_dot_product', + 'cl_khr_external_memory', + 'cl_khr_external_memory_dma_buf', + 'cl_khr_external_memory_dx', + 'cl_khr_external_memory_opaque_fd', + 'cl_khr_external_memory_win32', + 'cl_khr_external_semaphore', + 'cl_khr_external_semaphore_dx_fence', + 'cl_khr_external_semaphore_opaque_fd', + 'cl_khr_external_semaphore_sync_fd', + 'cl_khr_external_semaphore_win32', + 'cl_khr_semaphore', + 'cl_arm_import_memory', + 'cl_arm_shared_virtual_memory', + 'cl_arm_get_core_id', + 'cl_arm_job_slot_selection', + 'cl_arm_scheduling_controls', + 'cl_arm_controlled_kernel_termination', + 'cl_arm_protected_memory_allocation', + 'cl_intel_exec_by_local_thread', + 'cl_intel_device_attribute_query', + 'cl_intel_device_partition_by_names', + 'cl_intel_accelerator', + 'cl_intel_motion_estimation', + 'cl_intel_advanced_motion_estimation', + 'cl_intel_simultaneous_sharing', + 'cl_intel_egl_image_yuv', + 'cl_intel_packed_yuv', + 'cl_intel_required_subgroup_size', + 'cl_intel_driver_diagnostics', + 'cl_intel_planar_yuv', + 'cl_intel_device_side_avc_motion_estimation', + 'cl_intel_unified_shared_memory', + 'cl_intel_mem_alloc_buffer_location', + 'cl_intel_create_buffer_with_properties', + 'cl_intel_program_scope_host_pipe', + 'cl_intel_mem_channel_property', + 'cl_intel_mem_force_host_memory', + 'cl_intel_command_queue_families', + 'cl_intel_queue_no_sync_operations', + 'cl_intel_sharing_format_query', + 'cl_ext_image_requirements_info', + 'cl_ext_image_from_buffer', + 'cl_loader_info', + 'cl_khr_depth_images', + 'cl_ext_float_atomics', + 'cl_intel_create_mem_object_properties', + 'cl_pocl_content_size', + 'cl_ext_image_raw10_raw12', + # cl_d3d10.h + 'cl_khr_d3d10_sharing', + 'cl_intel_sharing_format_query_d3d10', + # cl_d3d11.h + 'cl_khr_d3d11_sharing', + 'cl_intel_sharing_format_query_d3d11', + # cl_dx9_media_sharing.h + 'cl_khr_dx9_media_sharing', + 'cl_intel_dx9_media_sharing', + 'cl_intel_sharing_format_query_dx9', + # cl_egl.h + 'cl_khr_egl_image', + 'cl_khr_egl_event', + # cl_gl.h + 'cl_khr_gl_sharing', + 'cl_khr_gl_event', + 'cl_khr_gl_depth_images', + 'cl_khr_gl_msaa_sharing', + 'cl_intel_sharing_format_query_gl', + # cl_layer.h + 'cl_loader_layers', + # cl_va_api_media_sharing_intel.h + 'cl_intel_sharing_format_query_va_api', + 'cl_intel_va_api_media_sharing', + ] + +def getExtensionSortKey(item): + name = item.get('name') + try: + index = orderedExtensions.index(name) + except ValueError: + if name.startswith('cl_khr'): + index = 10000 + elif name.startswith('cl_ext'): + index = 10001 + else: + index = 10002 + return index, name + +# Order the extensions should be emitted in the headers. +# KHR -> EXT -> Vendor Extensions +def getExtensionSortKey_ideal(item): + name = item.get('name') + if name.startswith('cl_khr'): + return 0, name + if name.startswith('cl_ext'): + return 1, name + return 99, name + +# Order enums should be emitted in the headers. +# Enums Without Bits -> Ordered Bit Enums +def getEnumSortKey(item): + name = item.get('name') + if name in enums: + if enums[name].Value: + return -1 + if enums[name].Bitpos: + return int(enums[name].Bitpos) + return 99 + +# Gets C function parameter strings for the specified API params: +def getCParameterStrings(params): + strings = [] + if len(params) == 0: + strings.append("void") + else: + for param in params: + paramstr = param.Type + ' ' + param.Name + param.TypeEnd + strings.append(paramstr) + return strings + +# Gets a bit string for the specified bit position: +def getBitPosString(bitpos): + ret = '(' + ret += '(cl_bitfield)' if int(bitpos) >= 31 else '' + ret += '1 << ' + ret += bitpos + ret += ')' + return ret + +# Extensions that are included in the ICD dispatch table for historical reasons. +# This should not be required for new extensions! +loaderExtensions = { + 'cl_ext_device_fission', + 'cl_khr_d3d10_sharing', + 'cl_khr_d3d11_sharing', + 'cl_khr_dx9_media_sharing', + 'cl_khr_egl_event', + 'cl_khr_egl_image', + 'cl_khr_gl_event', + 'cl_khr_gl_sharing', + 'cl_khr_subgroups' + } + +# Gets the preprocessor guard for the given extension: +def getPrototypeIfGuard(name): + if name in loaderExtensions: + guard = '!defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES)' + else: + guard = '!defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES)' + return guard + +# Names that have been generated already, since some may be shared by multiple +# extensions: +generatedNames = set() + +def isDuplicateName(name): + if name in generatedNames: + return True + generatedNames.add(name) + return False + +%>/******************************************************************************* + * Copyright (c) 2008-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 ${guard} +#define ${guard} + +/* +** This header is generated from the Khronos OpenCL XML API Registry. +*/ + +%if includes: +${includes} + +%endif +#include + +/* CL_NO_PROTOTYPES implies CL_NO_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_PROTOTYPES) && !defined(CL_NO_EXTENSION_PROTOTYPES) +#define CL_NO_EXTENSION_PROTOTYPES +#endif + +/* CL_NO_EXTENSION_PROTOTYPES implies + CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES and + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES: */ +#if defined(CL_NO_EXTENSION_PROTOTYPES) && ${"\\"} + !defined(CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif +#if defined(CL_NO_EXTENSION_PROTOTYPES) && ${"\\"} + !defined(CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES) +#define CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +%for extension in sorted(spec.findall('extensions/extension'), key=getExtensionSortKey): +% if shouldGenerate(extension.get('name')): +<% + name = extension.get('name') +%>/*************************************************************** +* ${name} +***************************************************************/ +%if extension.get('condition'): +#if ${extension.get('condition')} + +%endif +#define ${name} 1 +#define ${name.upper()}_EXTENSION_NAME ${"\\"} + "${name}" + +<% + # Use re.match to parse semantic major.minor.patch version + sem_ver = match('[0-9]+\.[0-9]+\.?[0-9]+', extension.get('revision')) + if not sem_ver: + raise TypeError(name + + ' XML revision field is not semantically versioned as "major.minor.patch"') + version = sem_ver[0].split('.') + major = version[0] + minor = version[1] + patch = version[2] +%> +#define ${name.upper()}_EXTENSION_VERSION CL_MAKE_VERSION(${major}, ${minor}, ${patch}) + +%for block in extension.findall('require'): +% if shouldEmit(block): +% if block.get('condition'): +#if ${block.get('condition')} +% endif +% if block.get('comment'): +/* ${block.get('comment')} */ +% endif +% for type in block.findall('type'): +% if isDuplicateName(type.get('name')): +/* type ${type.get('name')} */ +% else: +% if type.get('name') in typedefs: +${typedefs[type.get('name')].Typedef.ljust(27)} ${type.get('name')}; +% elif type.get('name') in macros: +#define ${type.get('name')}${macros[type.get('name')].Macro} +% elif type.get('name') in structs: +<% + struct = structs[type.get('name')] +%>typedef struct _${struct.Name} { +% for i, member in enumerate(struct.Members): + ${member.Type} ${member.Name}${member.TypeEnd}; +% endfor +} ${struct.Name}; +% else: +// type ${type.get('name')} not found! +% endif +% endif +% endfor +% for enum in sorted(block.findall('enum'), key=getEnumSortKey): +% if isDuplicateName(enum.get('name')): +/* enum ${enum.get('name')} */ +% else: +% if enum.get('name') in enums: +% if enums[enum.get('name')].Value: +#define ${enum.get('name').ljust(51)} ${enums[enum.get('name')].Value} +% elif enums[enum.get('name')].Bitpos: +#define ${enum.get('name').ljust(51)} ${getBitPosString(enums[enum.get('name')].Bitpos)} +% else: +// enum ${enum.get('name')} is unassigned! +% endif +% else: +// enum ${enum.get('name')} not found! +% endif +% endif +% endfor +% if block.findall('command'): +% for func in block.findall('command'): +<% + api = apisigs[func.get('name')] +%> +typedef ${api.RetType} CL_API_CALL +${api.Name}_t( +% for i, paramStr in enumerate(getCParameterStrings(api.Params)): +% if i < len(api.Params)-1: + ${paramStr}, +% else: + ${paramStr}); +% endif +% endfor + +typedef ${api.Name}_t * +${api.Name}_fn ${api.Suffix}; +% endfor +% if generate_pfn_typedefs: + +/* +** The function pointer typedefs prefixed with "pfn_" are provided for +** compatibility with earlier versions of the headers. New code is +** encouraged to use the function pointer typedefs that are suffixed with +** "_fn" instead, for consistency. +*/ +% for func in block.findall('command'): +<% + api = apisigs[func.get('name')] +%> +typedef ${api.Name}_t * +pfn_${api.Name} ${api.Suffix}; +% endfor +% endif + +#if ${getPrototypeIfGuard(name)} +% for func in block.findall('command'): +<% + api = apisigs[func.get('name')] +%> +extern CL_API_ENTRY ${api.RetType} CL_API_CALL +${api.Name}( +% for i, paramStr in enumerate(getCParameterStrings(api.Params)): +% if i < len(api.Params)-1: + ${paramStr}, +% else: + ${paramStr}) ${api.Suffix}; +% endif +% endfor +% endfor + +#endif /* ${getPrototypeIfGuard(name)} */ +% endif +% if block.get('condition'): + +#endif /* ${block.get('condition')} */ +% endif + +% endif +%endfor +%if extension.get('condition'): +#endif /* ${extension.get('condition')} */ + +%endif +% endif +%endfor +#ifdef __cplusplus +} +#endif + +#endif /* ${guard} */ diff --git a/deps/opencl-headers/scripts/cl_function_types.h.mako b/deps/opencl-headers/scripts/cl_function_types.h.mako new file mode 100644 index 000000000..7888e148c --- /dev/null +++ b/deps/opencl-headers/scripts/cl_function_types.h.mako @@ -0,0 +1,62 @@ +<% +# Gets C function parameter strings for the specified API params: +import sys +import json +def getCParameterStrings(params): + strings = [] + if len(params) == 0: + strings.append("void") + else: + for param in params: + paramstr = param.Type + ' ' + param.Name + param.TypeEnd + strings.append(paramstr) + return strings + +%>/* + * 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. + * + * OpenCL is a trademark of Apple Inc. used under license by Khronos. + */ + +#ifndef OPENCL_CL_FUNCTION_TYPES_H_ +#define OPENCL_CL_FUNCTION_TYPES_H_ + +#include + +%for version, apis in coreapis.items(): +% if version != "CL_VERSION_1_0": +#ifdef ${version} + +% endif +% for api in apis: +typedef ${api.RetType} CL_API_CALL ${api.Name}_t( +% for i, paramStr in enumerate(getCParameterStrings(api.Params)): +% if i < len(api.Params)-1: + ${paramStr}, +% else: + ${paramStr}); +% endif +% endfor + +typedef ${api.Name}_t * +${api.Name}_fn ${api.Suffix}; + +% endfor +% if version != "CL_VERSION_1_0": +#endif /* ${version} */ + +% endif +%endfor +#endif /* OPENCL_CL_FUNCTION_TYPES_H_ */ diff --git a/deps/opencl-headers/scripts/gen/__init__.py b/deps/opencl-headers/scripts/gen/__init__.py new file mode 100644 index 000000000..dbdf858bf --- /dev/null +++ b/deps/opencl-headers/scripts/gen/__init__.py @@ -0,0 +1,210 @@ +# 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. + +from collections import OrderedDict +from collections import namedtuple + +import argparse +import sys +import urllib +import xml.etree.ElementTree as etree +import urllib.request + +# parse_xml - Helper function to parse the XML file from a URL or local file. +def parse_xml(path): + file = urllib.request.urlopen(path) if path.startswith("http") else open(path, 'r') + with file: + tree = etree.parse(file) + return tree + +# noneStr - returns string argument, or "" if argument is None. +def noneStr(s): + if s: + return s + return "" + +def parse_args(): + parser = argparse.ArgumentParser() + + # To pull the latest registry file from GitHub, pass: + # -registry "https://raw.githubusercontent.com/KhronosGroup/OpenCL-Registry/master/xml/cl.xml" + + parser.add_argument('-registry', action='store', + default='cl.xml', + help='Use specified registry file instead of cl.xml') + parser.add_argument('-o', action='store', dest='directory', + default='.', + help='Create target and related files in specified directory') + + args = parser.parse_args() + return args + +def load_spec(args): + specpath = args.registry + + print('Parsing XML file from: ' + specpath) + spec = parse_xml(specpath) + return spec + +def get_apitypedefs(spec): + typedefs = OrderedDict() + Typedef = namedtuple('Typedef', 'Typedef Name') + print('Generating API typedef dictionary...') + for type in spec.findall('types/type'): + if type.get('category') == 'define': + if noneStr(type.text).startswith("typedef"): + typedef = noneStr(type.text) + name = "" + for elem in type: + if elem.tag == 'name': + name = noneStr(elem.text) + else: + typedef = typedef + noneStr(elem.text) + noneStr(elem.tail) + typedef = typedef.strip() + name = name.strip() + typedefs[name] = Typedef(typedef, name) + return typedefs + +def get_apimacros(spec): + macros = OrderedDict() + Macro = namedtuple('Macro', 'Define Name Macro') + print('Generating API macro dictionary...') + for type in spec.findall('types/type'): + if type.get('category') == 'define': + if noneStr(type.text).startswith("#define"): + define = noneStr(type.text) + name = "" + macro = "" + for elem in type: + if elem.tag == 'name': + name = noneStr(elem.text) + macro = macro + noneStr(elem.tail) + define = define.strip() + name = name.strip() + macro = macro.rstrip() # keep spaces on the left! + macros[name] = Macro(define, name, macro) + return macros + +def get_apistructs(spec): + structs = OrderedDict() + Struct = namedtuple('Struct', 'Name Members') + StructMember = namedtuple('StructMember', 'Type TypeEnd Name') + print('Generating API struct dictionary...') + for type in spec.findall('types/type'): + if type.get('category') == 'struct': + name = type.get('name') + mlist = [] + for member in type.findall('member'): + mtype = noneStr(member.text) + mtypeend = "" + mname = "" + for elem in member: + if elem.tag == 'name': + mname = noneStr(elem.text) + mtypeend = noneStr(elem.tail) + elif elem.tag == 'enum': + # Assumes any additional enums are for array limits, e.g.: + # charname[CL_NAME_VERSION_MAX_NAME_SIZE] + mtypeend = mtypeend + noneStr(elem.text) + noneStr(elem.tail) + else: + mtype = mtype + noneStr(elem.text) + noneStr(elem.tail) + mtype = mtype.strip() + mtypeend = mtypeend.strip() + mname = mname.strip() + mlist.append(StructMember(mtype, mtypeend, mname)) + structs[name] = Struct(name, mlist) + return structs + +def get_apienums(spec): + enums = OrderedDict() + Enum = namedtuple('Enum', 'Value Bitpos Name') + print('Generating API enum dictionary...') + for enum in spec.findall('enums/enum'): + value = enum.get('value') + bitpos = enum.get('bitpos') + name = enum.get('name') + enums[name] = Enum(value, bitpos, name) + return enums + +def get_apisigs(spec): + apisigs = OrderedDict() + ApiSignature = namedtuple('ApiSignature', 'Name RetType Params Suffix') + ApiParam = namedtuple('ApiParam', 'Type TypeEnd Name') + print('Generating API signatures dictionary...') + for command in spec.findall('commands/command'): + suffix = noneStr(command.get('suffix')) + proto = command.find('proto') + ret = noneStr(proto.text) + name = "" + params = "" + for elem in proto: + if elem.tag == 'name': + name = noneStr(elem.text) + noneStr(elem.tail) + else: + ret = ret + noneStr(elem.text) + noneStr(elem.tail) + ret = ret.strip() + name = name.strip() + + plist = [] + for param in command.findall('param'): + ptype = noneStr(param.text) + ptypeend = "" + pname = "" + for elem in param: + if elem.tag == 'name': + pname = noneStr(elem.text) + ptypeend = noneStr(elem.tail) + else: + ptype = ptype + noneStr(elem.text) + noneStr(elem.tail) + ptype = ptype.strip() + ptypeend = ptypeend.strip() + pname = pname.strip() + plist.append(ApiParam(ptype, ptypeend, pname)) + + # For an empty parameter list (for e.g. clUnloadCompiler), add a single + # unnamed void parameter to make generation easier. + if len(plist) == 0: + plist.append(ApiParam("void", "", "")) + + apisigs[name] = ApiSignature(name, ret, plist, suffix) + return apisigs + +def get_coreapis(spec, apisigs): + coreapis = OrderedDict() + print('Generating core API dictionary...') + for feature in spec.findall('feature'): + version = noneStr(feature.get('name')) + + alist = [] + for function in feature.findall('require/command'): + name = function.get('name') + alist.append(apisigs[name]) + coreapis[version] = alist + return coreapis + +def get_extapis(spec, apisigs): + extapis = OrderedDict() + print('Generating API extensions dictionary...') + for feature in spec.findall('extensions/extension'): + extension = noneStr(feature.get('name')) + + alist = [] + for function in feature.findall('require/command'): + name = function.get('name') + alist.append(apisigs[name]) + extapis[extension] = alist + return extapis + +def get_apis(spec, apisigs): + return (get_coreapis(spec, apisigs), get_extapis(spec, apisigs)) diff --git a/deps/opencl-headers/scripts/gen_headers.py b/deps/opencl-headers/scripts/gen_headers.py new file mode 100644 index 000000000..4bfaa0e40 --- /dev/null +++ b/deps/opencl-headers/scripts/gen_headers.py @@ -0,0 +1,240 @@ +#!/usr/bin/python3 + +# 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. + +import gen +import re + +from mako.template import Template +from mako.exceptions import RichTraceback + +from collections import OrderedDict +from collections import namedtuple + +def getDisableWarningIncludeString(include): + warningPush = """#if defined(_MSC_VER) +#if _MSC_VER >=1500 +#pragma warning( push ) +#pragma warning( disable : 4201 ) +#pragma warning( disable : 5105 ) +#endif +#endif +""" + warningPop = """ +#if defined(_MSC_VER) +#if _MSC_VER >=1500 +#pragma warning( pop ) +#endif +#endif""" + return warningPush + include + warningPop + +def getWin32OnlyIncludeString(include): + return """#if defined(_WIN32) +""" + include + """ +#endif""" + +if __name__ == "__main__": + args = gen.parse_args() + spec = gen.load_spec(args) + + typedefs = gen.get_apitypedefs(spec) + macros = gen.get_apimacros(spec) + structs = gen.get_apistructs(spec) + enums = gen.get_apienums(spec) + apisigs = gen.get_apisigs(spec) + + coreapis = gen.get_coreapis(spec, apisigs) + extapis = gen.get_extapis(spec, apisigs) + + try: + cl_ext_h_template = Template(filename='cl_ext.h.mako', input_encoding='utf-8') + cl_function_types_h_template = Template(filename='cl_function_types.h.mako', input_encoding='utf-8') + + print('Generating cl_dx9_media_sharing.h...') + text = cl_ext_h_template.render( + genExtensions={ + 'cl_khr_dx9_media_sharing', + 'cl_intel_dx9_media_sharing', + 'cl_intel_sharing_format_query_dx9', + }, + guard="OPENCL_CL_DX9_MEDIA_SHARING_H_", + includes=getWin32OnlyIncludeString(getDisableWarningIncludeString("#include ")), + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_dx9_media_sharing.h', 'w') as gen: + gen.write(text) + + print('Generating cl_d3d10.h...') + text = cl_ext_h_template.render( + genExtensions={ + 'cl_khr_d3d10_sharing', + 'cl_intel_sharing_format_query_d3d10', + }, + guard="OPENCL_CL_D3D10_H_", + includes=getDisableWarningIncludeString("#include "), + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_d3d10.h', 'w') as gen: + gen.write(text) + + print('Generating cl_d3d11.h...') + text = cl_ext_h_template.render( + genExtensions={ + 'cl_khr_d3d11_sharing', + 'cl_intel_sharing_format_query_d3d11' + }, + guard="OPENCL_CL_D3D11_H_", + includes=getDisableWarningIncludeString("#include "), + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_d3d11.h', 'w') as gen: + gen.write(text) + + print('Generating cl_egl.h...') + text = cl_ext_h_template.render( + genExtensions={'cl_khr_egl_event', 'cl_khr_egl_image'}, + guard="OPENCL_CL_EGL_H_", + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_egl.h', 'w') as gen: + gen.write(text) + + print('Generating cl_gl.h...') + text = cl_ext_h_template.render( + genExtensions={ + 'cl_khr_gl_depth_images', + 'cl_khr_gl_event', + 'cl_khr_gl_msaa_sharing', + 'cl_khr_gl_sharing', + 'cl_intel_sharing_format_query_gl', + }, + guard="OPENCL_CL_GL_H_", + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_gl.h', 'w') as gen: + gen.write(text) + + print('Generating cl_layer.h...') + text = cl_ext_h_template.render( + genExtensions={'cl_loader_layers'}, + guard="OPENCL_CL_LAYER_H_", + includes='#include ', + generate_pfn_typedefs=True, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_layer.h', 'w') as gen: + gen.write(text) + + print('Generating cl_va_api_media_sharing_intel.h...') + text = cl_ext_h_template.render( + genExtensions={ + 'cl_intel_va_api_media_sharing', + 'cl_intel_sharing_format_query_va_api', + }, + guard="OPENCL_CL_VA_API_MEDIA_SHARING_INTEL_H_", + includes='#include ', + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_va_api_media_sharing_intel.h', 'w') as gen: + gen.write(text) + + print('Generating cl_ext.h...') + text = cl_ext_h_template.render( + genExtensions={}, + guard="OPENCL_CL_EXT_H_", + generate_pfn_typedefs=False, + spec=spec, + typedefs=typedefs, + macros=macros, + structs=structs, + enums=enums, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_ext.h', 'w') as gen: + gen.write(text) + + print('Generating cl_function_types.h...') + text = cl_function_types_h_template.render( + spec=spec, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis) + text = re.sub(r'\r\n', r'\n', text) + with open(args.directory + '/cl_function_types.h', 'w') as gen: + gen.write(text) + + except: + traceback = RichTraceback() + for (filename, lineno, function, line) in traceback.traceback: + print('%s(%s) : error in %s' % (filename, lineno, function)) + print(' ', line) + print('%s: %s' % (str(traceback.error.__class__.__name__), traceback.error)) diff --git a/deps/opencl-headers/scripts/requirements.txt b/deps/opencl-headers/scripts/requirements.txt new file mode 100644 index 000000000..650c29a4d --- /dev/null +++ b/deps/opencl-headers/scripts/requirements.txt @@ -0,0 +1 @@ +Mako>=1.2.2 diff --git a/deps/opencl-headers/tests/CMakeLists.txt b/deps/opencl-headers/tests/CMakeLists.txt index a2a205ace..24f043305 100644 --- a/deps/opencl-headers/tests/CMakeLists.txt +++ b/deps/opencl-headers/tests/CMakeLists.txt @@ -1,3 +1,17 @@ +if(NOT DEFINED CMAKE_C_STANDARD) + set(CMAKE_C_STANDARD 99) +endif() +if(NOT DEFINED CMAKE_C_STANDARD_REQUIRED) + set(CMAKE_C_STANDARD_REQUIRED ON) +endif() +if(NOT DEFINED CMAKE_CXX_STANDARD) + set(CMAKE_CXX_STANDARD 17) +endif() +if(NOT DEFINED CMAKE_CXX_STANDARD_REQUIRED) + set(CMAKE_CXX_STANDARD_REQUIRED ON) +endif() + + # Add a test for a given source file for each version of OpenCL function(add_header_test NAME SOURCE) # Some headers include system files which require anonymous structs diff --git a/deps/opencl-headers/tests/lang_c/CMakeLists.txt b/deps/opencl-headers/tests/lang_c/CMakeLists.txt index 0678ddef0..df8cd5c60 100644 --- a/deps/opencl-headers/tests/lang_c/CMakeLists.txt +++ b/deps/opencl-headers/tests/lang_c/CMakeLists.txt @@ -16,3 +16,4 @@ add_header_test(cl_platform_h test_cl_platform.h.c) add_header_test(cl_opencl_h test_opencl.h.c) add_header_test(cl_version_h test_cl_version.h.c) add_header_test(headers test_headers.c) +add_header_test(ext_headers test_ext_headers.c) diff --git a/deps/opencl-headers/tests/lang_cpp/CMakeLists.txt b/deps/opencl-headers/tests/lang_cpp/CMakeLists.txt index 0678ddef0..f4ef23417 100644 --- a/deps/opencl-headers/tests/lang_cpp/CMakeLists.txt +++ b/deps/opencl-headers/tests/lang_cpp/CMakeLists.txt @@ -15,4 +15,4 @@ add_header_test(cl_layer_h test_cl_layer.h.c) add_header_test(cl_platform_h test_cl_platform.h.c) add_header_test(cl_opencl_h test_opencl.h.c) add_header_test(cl_version_h test_cl_version.h.c) -add_header_test(headers test_headers.c) +add_header_test(ext_headers test_ext_headers.c) diff --git a/deps/opencl-headers/tests/pkgconfig/bare/CMakeLists.txt b/deps/opencl-headers/tests/pkgconfig/bare/CMakeLists.txt index 866831a73..f3e8466ee 100644 --- a/deps/opencl-headers/tests/pkgconfig/bare/CMakeLists.txt +++ b/deps/opencl-headers/tests/pkgconfig/bare/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES C @@ -21,3 +21,10 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE CL_TARGET_OPENCL_VERSION=120 ) + +include(CTest) + +add_test( + NAME ${PROJECT_NAME} + COMMAND ${PROJECT_NAME} +) diff --git a/deps/opencl-headers/tests/pkgconfig/pkgconfig.c b/deps/opencl-headers/tests/pkgconfig/pkgconfig.c index d4c1f013d..a520a1300 100644 --- a/deps/opencl-headers/tests/pkgconfig/pkgconfig.c +++ b/deps/opencl-headers/tests/pkgconfig/pkgconfig.c @@ -1,6 +1,3 @@ #include -int main() -{ - return sizeof(cl_platform_id) - sizeof(cl_context); -} +int main(void) { return sizeof(cl_platform_id) - sizeof(cl_context); } diff --git a/deps/opencl-headers/tests/pkgconfig/sdk/CMakeLists.txt b/deps/opencl-headers/tests/pkgconfig/sdk/CMakeLists.txt index 75f56049f..aa36d168b 100644 --- a/deps/opencl-headers/tests/pkgconfig/sdk/CMakeLists.txt +++ b/deps/opencl-headers/tests/pkgconfig/sdk/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES C @@ -22,3 +22,10 @@ target_compile_definitions(${PROJECT_NAME} PRIVATE CL_TARGET_OPENCL_VERSION=120 ) + +include(CTest) + +add_test( + NAME ${PROJECT_NAME} + COMMAND ${PROJECT_NAME} +) diff --git a/deps/opencl-headers/tests/test_ext_headers.c b/deps/opencl-headers/tests/test_ext_headers.c new file mode 100644 index 000000000..e50ba50b8 --- /dev/null +++ b/deps/opencl-headers/tests/test_ext_headers.c @@ -0,0 +1,56 @@ +// +// 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 "CL/cl_ext.h" +#include +#include + +int extVersionMacro(void) +{ + // Test a non-provisional extension with non-placeholder semantic version. + printf("Checking version macro for the cl_khr_integer_dot_product " + "extension\n"); + + cl_version ExtVersion = CL_KHR_INTEGER_DOT_PRODUCT_EXTENSION_VERSION; + cl_version ExtMajorVersion = CL_VERSION_MAJOR(ExtVersion); + cl_version ExtMinorVersion = CL_VERSION_MINOR(ExtVersion); + cl_version ExtPatchVersion = CL_VERSION_PATCH(ExtVersion); + + printf("cl_khr_integer_dot_product version value %" PRIu32 + " which is semantic version %" PRIu32 ".%" PRIu32 ".%" PRIu32 "\n", + ExtVersion, ExtMajorVersion, ExtMinorVersion, ExtPatchVersion); + + // Test vendor extension which uses default semantic version. + printf("Checking version macro for the cl_APPLE_SetMemObjectDestructor\n"); + + ExtVersion = CL_APPLE_SETMEMOBJECTDESTRUCTOR_EXTENSION_VERSION; + ExtMajorVersion = CL_VERSION_MAJOR(ExtVersion); + ExtMinorVersion = CL_VERSION_MINOR(ExtVersion); + ExtPatchVersion = CL_VERSION_PATCH(ExtVersion); + + printf("cl_APPLE_SetMemObjectDestructor version value %" PRIu32 + " which is semantic version %" PRIu32 ".%" PRIu32 ".%" PRIu32 "\n", + ExtVersion, ExtMajorVersion, ExtMinorVersion, ExtPatchVersion); + + return 0; +} + +int main(void) +{ + int Result = extVersionMacro(); + + return Result; +} diff --git a/deps/opencl-headers/tests/test_headers.c b/deps/opencl-headers/tests/test_headers.c index 71f79bbfe..65e5f5d0a 100644 --- a/deps/opencl-headers/tests/test_headers.c +++ b/deps/opencl-headers/tests/test_headers.c @@ -1,5 +1,5 @@ // -// Copyright (c) 2020 The Khronos Group Inc. +// Copyright (c) 2020-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. @@ -14,12 +14,22 @@ // limitations under the License. // +/* +Some versions of inttypes.h required defining the macro __STDC_FORMAT_MACROS to +use the format macros for C++ compiles, but not all. To improve robustness we +will use inttypes.h for C compiles and cinttypes for C++ compiles. +*/ +#if defined(__cplusplus) +#include +#else #include +#endif + #include #include "CL/cl.h" -int test_char() +int test_char(void) { /* char */ /* Constructor */ @@ -79,7 +89,7 @@ int test_char() return 0; } -int test_uchar() +int test_uchar(void) { /* uchar */ /* Constructor */ @@ -139,7 +149,7 @@ int test_uchar() return 0; } -int test_short() +int test_short(void) { /* short */ /* Constructor */ @@ -199,7 +209,7 @@ int test_short() return 0; } -int test_ushort() +int test_ushort(void) { /* ushort */ /* Constructor */ @@ -259,7 +269,7 @@ int test_ushort() return 0; } -int test_int() +int test_int(void) { /* int */ /* Constructor */ @@ -319,7 +329,7 @@ int test_int() return 0; } -int test_uint() +int test_uint(void) { /* uint */ /* Constructor */ @@ -379,7 +389,7 @@ int test_uint() return 0; } -int test_long() +int test_long(void) { /* long */ /* Constructor */ @@ -439,7 +449,7 @@ int test_long() return 0; } -int test_ulong() +int test_ulong(void) { /* ulong */ /* Constructor */ @@ -499,7 +509,7 @@ int test_ulong() return 0; } -int test_float() +int test_float(void) { /* float */ /* Constructor */ @@ -561,7 +571,7 @@ int test_float() return 0; } -int test_double() +int test_double(void) { /* double */ /* Constructor */ From 1fb32eed5ac21d3dcf697ea15b156cf568d0a85e Mon Sep 17 00:00:00 2001 From: Vladimir Kutuev Date: Mon, 19 May 2025 18:03:33 +0300 Subject: [PATCH 2/8] gh-233: update opencl-headers-hpp dependency --- .../.github/workflows/linux.yml | 321 -- .../.github/workflows/macos.yml | 159 - .../.github/workflows/presubmit.yml | 860 +++ .../.github/workflows/release.yml | 76 + .../.github/workflows/windows.yml | 213 - deps/opencl-headers-hpp/.gitignore | 14 + deps/opencl-headers-hpp/.gitmodules | 3 - deps/opencl-headers-hpp/CMakeLists.txt | 262 +- deps/opencl-headers-hpp/OpenCL-CLHPP.pc.in | 8 + deps/opencl-headers-hpp/README.md | 188 +- .../cmake/DebSourcePkg.cmake | 151 + deps/opencl-headers-hpp/cmake/JoinPaths.cmake | 26 + deps/opencl-headers-hpp/cmake/Package.cmake | 47 + .../cmake/PackageSetup.cmake | 56 + .../examples/CMakeLists.txt | 4 +- .../examples/src/CMakeLists.txt | 64 +- .../examples/src/headerexample.cpp | 4 +- .../examples/src/trivial.cpp | 4 +- .../examples/src/trivialSizeTCompat.cpp | 8 +- deps/opencl-headers-hpp/include/CL/opencl.hpp | 5038 +++++++++++------ deps/opencl-headers-hpp/tests/CMakeLists.txt | 341 +- deps/opencl-headers-hpp/tests/ToAdd.txt | 16 +- deps/opencl-headers-hpp/tests/cmock.yml | 1 + .../tests/pkgconfig/bare/CMakeLists.txt | 2 +- .../tests/pkgconfig/sdk/CMakeLists.txt | 2 +- .../tests/strip_defines.cmake | 2 +- .../tests/test_openclhpp.cpp | 4640 +++++++++++---- .../tests/test_versions.cpp | 24 + 28 files changed, 8746 insertions(+), 3788 deletions(-) delete mode 100644 deps/opencl-headers-hpp/.github/workflows/linux.yml delete mode 100644 deps/opencl-headers-hpp/.github/workflows/macos.yml create mode 100644 deps/opencl-headers-hpp/.github/workflows/presubmit.yml create mode 100644 deps/opencl-headers-hpp/.github/workflows/release.yml delete mode 100644 deps/opencl-headers-hpp/.github/workflows/windows.yml create mode 100644 deps/opencl-headers-hpp/.gitignore create mode 100644 deps/opencl-headers-hpp/OpenCL-CLHPP.pc.in create mode 100644 deps/opencl-headers-hpp/cmake/DebSourcePkg.cmake create mode 100644 deps/opencl-headers-hpp/cmake/JoinPaths.cmake create mode 100644 deps/opencl-headers-hpp/cmake/Package.cmake create mode 100644 deps/opencl-headers-hpp/cmake/PackageSetup.cmake create mode 100644 deps/opencl-headers-hpp/tests/test_versions.cpp diff --git a/deps/opencl-headers-hpp/.github/workflows/linux.yml b/deps/opencl-headers-hpp/.github/workflows/linux.yml deleted file mode 100644 index edd15cc67..000000000 --- a/deps/opencl-headers-hpp/.github/workflows/linux.yml +++ /dev/null @@ -1,321 +0,0 @@ -name: Linux - -on: [push, pull_request] - -jobs: - cmake-minimum: - runs-on: ${{ matrix.OS }} - strategy: - matrix: - OS: [ubuntu-18.04] - VER: [7, 8] # clang-8, clang-10 - EXT: [ON, OFF] - GEN: [Unix Makefiles] - CONFIG: [Debug, Release] - STD: [11, 14] - BIN: [64] # Temporarily disable cross-compilation (will need toolchain files) - CMAKE: [3.1.3] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{ matrix.CMAKE }}/cmake-${{ matrix.CMAKE }}-Linux-x86_64.tar.gz - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - - steps: - - name: Checkout OpenCL-CLHPP - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-ICD-Loader - path: external/OpenCL-ICD-Loader - - - name: Create Build Environment - run: sudo apt-get update -q; - if [[ "${{matrix.GEN}}" =~ "Ninja" && ! `which ninja` ]]; then sudo apt install -y ninja-build; fi; - sudo apt install gcc-${{matrix.VER}} g++-${{matrix.VER}}; - if [[ "${{matrix.BIN}}" == "32" ]]; - then sudo apt install gcc-${COMPILER_VER}-multilib; - fi; - mkdir -p /opt/Kitware/CMake; - wget -c $CMAKE_URL -O - | tar -xz --directory /opt/Kitware/CMake; - mv /opt/Kitware/CMake/cmake-${{ matrix.CMAKE }}-* /opt/Kitware/CMake/${{ matrix.CMAKE }} - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B$GITHUB_WORKSPACE/external/OpenCL-Headers/build - -H$GITHUB_WORKSPACE/external/OpenCL-Headers && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - -- - -j`nproc` - - - name: Build & install OpenCL-ICD-Loader - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install - -B$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build - -H$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build - --target install - -- - -j`nproc` - - - name: Configure - shell: bash - # no -Werror during configuration because: - # warning: ISO C forbids assignment between function pointer and ‘void *’ [-Wpedantic] - # warning: unused parameter [-Wunused-parameter] - run: - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTS=ON - -D BUILD_EXAMPLES=ON - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" - -B$GITHUB_WORKSPACE/build - -H$GITHUB_WORKSPACE - - - name: Build - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - -- - -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build - shell: bash - run: $CTEST_EXE --output-on-failure --parallel `nproc` - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/bare - -H$GITHUB_WORKSPACE/tests/pkgconfig/bare ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/bare ; - cd $GITHUB_WORKSPACE/build/downstream/bare ; - $CTEST_EXE --output-on-failure - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e 'include("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/sdk - -H$GITHUB_WORKSPACE/tests/pkgconfig/sdk ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/sdk ; - cd $GITHUB_WORKSPACE/build/downstream/sdk ; - $CTEST_EXE --output-on-failure - - - - - - cmake-latest: - runs-on: ${{ matrix.OS }} - strategy: - matrix: - OS : [ubuntu-20.04] - VER: [9, 11] # clang-11, clang-13 - EXT: [ON, OFF] - GEN: [Ninja Multi-Config] - STD: [11, 14] - BIN: [64] # Temporarily disable cross-compilation (will need toolchain files) - CMAKE: [3.21.2] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{ matrix.CMAKE }}/cmake-${{ matrix.CMAKE }}-Linux-x86_64.tar.gz - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - - steps: - - name: Checkout OpenCL-CLHPP - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-ICD-Loader - path: external/OpenCL-ICD-Loader - - - name: Create Build Environment - run: sudo apt-get update -q; - if [[ "${{matrix.GEN}}" =~ "Ninja" && ! `which ninja` ]]; then sudo apt install -y ninja-build; fi; - sudo apt install gcc-${{matrix.VER}} g++-${{matrix.VER}}; - if [[ "${{matrix.BIN}}" == "32" ]]; - then sudo apt install gcc-${COMPILER_VER}-multilib; - fi; - mkdir -p /opt/Kitware/CMake; - wget -c $CMAKE_URL -O - | tar -xz --directory /opt/Kitware/CMake; - mv /opt/Kitware/CMake/cmake-${{ matrix.CMAKE }}-* /opt/Kitware/CMake/${{ matrix.CMAKE }} - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B$GITHUB_WORKSPACE/external/OpenCL-Headers/build - -H$GITHUB_WORKSPACE/external/OpenCL-Headers && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - --config Release - -- - -j`nproc` - - - name: Build & install OpenCL-ICD-Loader - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install - -B$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build - -H$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build - --target install - --config Release - -- - -j`nproc` - - - name: Configure - shell: bash - # no -Werror during configuration because: - # warning: ISO C forbids assignment between function pointer and ‘void *’ [-Wpedantic] - # warning: unused parameter [-Wunused-parameter] - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTS=ON - -D BUILD_EXAMPLES=ON - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" - -B$GITHUB_WORKSPACE/build - -H$GITHUB_WORKSPACE - - - name: Build - shell: bash - run: | - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release -- -j`nproc`; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug -- -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build - shell: bash - run: | - $CTEST_EXE --output-on-failure -C Release --parallel `nproc`; - $CTEST_EXE --output-on-failure -C Debug --parallel `nproc`; - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - --config Release - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/bare - -H$GITHUB_WORKSPACE/tests/pkgconfig/bare ; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/bare; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e 'include("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_CXX_COMPILER=g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/sdk - -H$GITHUB_WORKSPACE/tests/pkgconfig/sdk ; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/sdk; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; diff --git a/deps/opencl-headers-hpp/.github/workflows/macos.yml b/deps/opencl-headers-hpp/.github/workflows/macos.yml deleted file mode 100644 index 2fe7ed0a8..000000000 --- a/deps/opencl-headers-hpp/.github/workflows/macos.yml +++ /dev/null @@ -1,159 +0,0 @@ -name: MacOS - -on: [push, pull_request] - -jobs: - macos-gcc: - runs-on: macos-latest - strategy: - matrix: - VER: [9, 11] - EXT: [ON, OFF] - GEN: [Xcode, Ninja Multi-Config] - STD: [11, 17] - - steps: - - name: Checkout OpenCL-CLHPP - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-ICD-Loader - path: external/OpenCL-ICD-Loader - - - name: Create Build Environment - run: | - cmake -E make_directory $GITHUB_WORKSPACE/build; - cmake -E make_directory $GITHUB_WORKSPACE/install; - if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi; - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: cmake - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w" - -D CMAKE_C_COMPILER=/usr/local/bin/gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -S $GITHUB_WORKSPACE/external/OpenCL-Headers - -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && - cmake - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - --config Release - --parallel `sysctl -n hw.logicalcpu` && - ls -al $GITHUB_WORKSPACE/external/OpenCL-Headers/install && - ls -al $GITHUB_WORKSPACE/external/OpenCL-Headers/install/include && - ls -al $GITHUB_WORKSPACE/external/OpenCL-Headers/install/include/CL && - ls -al $GITHUB_WORKSPACE/external/OpenCL-Headers/install/include/OpenCL - - - name: Build & install OpenCL-ICD-Loader - run: cmake - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w -m64" - -D CMAKE_C_COMPILER=/usr/local/bin/gcc-${{matrix.VER}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install - -S $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader - -B $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build && - cmake - --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build - --target install - --config Release - --parallel `sysctl -n hw.logicalcpu` - - - name: Configure CMake - # no -Werror during configuration because: - # warning: ISO C forbids assignment between function pointer and ‘void *’ [-Wpedantic] - # warning: unused parameter [-Wunused-parameter] - shell: bash - run: cmake - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -Wno-format -m64" - -D CMAKE_CXX_COMPILER=/usr/local/bin/g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" - -S $GITHUB_WORKSPACE - -B $GITHUB_WORKSPACE/build - - - name: Build (Xcode) - if: matrix.GEN == 'Xcode' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` - cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` - cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build - shell: bash - run: | - ctest -C Release --output-on-failure --parallel `sysctl -n hw.logicalcpu` - ctest -C Debug --output-on-failure --parallel `sysctl -n hw.logicalcpu` - - - name: Install (Xcode) - if: matrix.GEN == 'Xcode' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --target install - - - name: Install (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --target install - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: cmake - -G "${{matrix.GEN}}" - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m64" - -D CMAKE_CXX_COMPILER=/usr/local/bin/g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/bare - -H$GITHUB_WORKSPACE/tests/pkgconfig/bare ; - cmake --build $GITHUB_WORKSPACE/build/downstream/bare --config Release ; - cmake --build $GITHUB_WORKSPACE/build/downstream/bare --config Debug ; - cd $GITHUB_WORKSPACE/build/downstream/bare ; - ctest --output-on-failure -C Release ; - ctest --output-on-failure -C Debug - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: cmake -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e 'include("/Users/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("/Users/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - cmake - -G "${{matrix.GEN}}" - -D CMAKE_CXX_FLAGS="-Wall -Wextra -pedantic -m64" - -D CMAKE_CXX_COMPILER=/usr/local/bin/g++-${{matrix.VER}} - -D CMAKE_CXX_STANDARD=${{matrix.STD}} - -D CMAKE_CXX_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" - -B$GITHUB_WORKSPACE/build/downstream/sdk - -H$GITHUB_WORKSPACE/tests/pkgconfig/sdk ; - cmake --build $GITHUB_WORKSPACE/build/downstream/sdk --config Release ; - cmake --build $GITHUB_WORKSPACE/build/downstream/sdk --config Debug ; - cd $GITHUB_WORKSPACE/build/downstream/sdk ; - ctest --output-on-failure -C Release ; - ctest --output-on-failure -C Debug \ No newline at end of file diff --git a/deps/opencl-headers-hpp/.github/workflows/presubmit.yml b/deps/opencl-headers-hpp/.github/workflows/presubmit.yml new file mode 100644 index 000000000..b6f2c931d --- /dev/null +++ b/deps/opencl-headers-hpp/.github/workflows/presubmit.yml @@ -0,0 +1,860 @@ +name: Presubmit + +on: [push, pull_request] + +jobs: + linux: + runs-on: ubuntu-latest + defaults: + run: + shell: bash + strategy: + matrix: + CMAKE: [3.26.4] + COMPILER: + - C_NAME: gcc + CXX_NAME: g++ + VER: 11 + - C_NAME: gcc + CXX_NAME: g++ + VER: 13 + - C_NAME: clang + CXX_NAME: clang++ + VER: 14 + - C_NAME: clang + CXX_NAME: clang++ + VER: 16 + BIN: [64] + CXXSTD: [11, 17] + CONF: + - GEN: Unix Makefiles + CONFIG: Debug + - GEN: Unix Makefiles + CONFIG: Release + - GEN: Ninja Multi-Config + CONFIG: Release + IMAGE: + - khronosgroup/docker-images:opencl-sdk-base-ubuntu-22.04.20230717 + include: + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 64 + CXXSTD: 11 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-base-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 64 + CXXSTD: 11 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-base-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 32 + CXXSTD: 11 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-base-ubuntu-20.04.20230717 + - CMAKE: system + COMPILER: + C_NAME: gcc + CXX_NAME: g++ + VER: 9 + BIN: 32 + CXXSTD: 11 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-base-ubuntu-20.04.20230717 + container: ${{matrix.IMAGE}} + env: + CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake + CPACK_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cpack + CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest + DEB_INSTALLATION_PATH: /usr + CC: ${{matrix.COMPILER.C_NAME}}-${{matrix.COMPILER.VER}} + CXX: ${{matrix.COMPILER.CXX_NAME}}-${{matrix.COMPILER.VER}} + CFLAGS: -Wall -Wextra -pedantic -Werror -m${{matrix.BIN}} + CXXFLAGS: -Wall -Wextra -pedantic -Werror -m${{matrix.BIN}} + + steps: + - name: Install system CMake + if: ${{matrix.CMAKE}} == 'system' + run: apt-get update -qq && apt-get install -y cmake && + echo "CMAKE_EXE=cmake" >> "$GITHUB_ENV" && + echo "CPACK_EXE=cpack" >> "$GITHUB_ENV" && + echo "CTEST_EXE=ctest" >> "$GITHUB_ENV" + + - name: Checkout OpenCL-CLHPP + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + path: external/OpenCL-Headers + repository: KhronosGroup/OpenCL-Headers + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + with: + path: external/OpenCL-ICD-Loader + repository: KhronosGroup/OpenCL-ICD-Loader + + - name: Configure, install & package OpenCL-Headers + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH + -D BUILD_TESTING=OFF + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + $CMAKE_EXE + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + --parallel `nproc` && + $CPACK_EXE + --config "$GITHUB_WORKSPACE/external/OpenCL-Headers/build/CPackConfig.cmake" + -G DEB + -C ${{matrix.CONF.CONFIG}} + -B "$GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb" + + - name: Configure & install OpenCL-ICD-Loader + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D BUILD_TESTING=OFF + -S $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader + -B $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build && + $CMAKE_EXE + --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build + --target install + --parallel `nproc` + + - name: Configure + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + -D BUILD_TESTING=ON + -D BUILD_EXAMPLES=ON + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} + -D CMAKE_CXX_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config ${{matrix.CONF.CONFIG}} --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release; + fi + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE --output-on-failure --no-tests=error -C Debug --parallel `nproc`; + $CTEST_EXE --output-on-failure --no-tests=error -C Release --parallel `nproc`; + fi + + - name: Package DEB + run: $CPACK_EXE + --config "$GITHUB_WORKSPACE/build/CPackConfig.cmake" + -G DEB + -C ${{matrix.CONF.CONFIG}} + -B "$GITHUB_WORKSPACE/package-deb" + + - name: Consume (DEB) + run: dpkg -i $GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb/*.deb && + dpkg -i $GITHUB_WORKSPACE/package-deb/*.deb && + $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} + -D CMAKE_CXX_EXTENSIONS=OFF + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_package && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config ${{matrix.CONF.CONFIG}} --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Release; + fi + + - name: Run consume test (DEB) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build_package + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (DEB) + # /usr/include is already on the include search path, + # we don't expect any output + run: | + # First check if OpenCL-Headers is locatable + pkg-config OpenCL-CLHPP --cflags + # Then check if the output is empty + if [[ "$(pkg-config OpenCL-CLHPP --cflags)" ]]; + then + exit 1; + fi; + + - name: Uninstall (DEB) + run: apt-get remove -y opencl-c-headers opencl-clhpp-headers + + - name: Test install + run: $CMAKE_EXE --build $GITHUB_WORKSPACE/build --target install --config ${{matrix.CONF.CONFIG}} --parallel `nproc` + + - name: Consume (install) + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Release; + fi + + - name: Run consume test (install) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build_install + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (install) + run: PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/share/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig + pkg-config OpenCL-CLHPP --cflags | grep -q "\-I$GITHUB_WORKSPACE/install/include" + + windows: + runs-on: windows-latest + defaults: + run: + shell: pwsh + strategy: + matrix: + VER: [v142, v143, clangcl] + GEN: [Visual Studio 17 2022, Ninja Multi-Config] + BIN: [x64] + CXXSTD: [11, 17] + exclude: + - VER: clangcl + GEN: Ninja Multi-Config + include: + - VER: v142 + GEN: Visual Studio 17 2022 + BIN: x86 + CXXSTD: 11 + env: + NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip + NINJA_ROOT: C:\Tools\Ninja + VS_ROOT: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' + UseMultiToolTask: true # Better parallel MSBuild execution + EnforceProcessCountAcrossBuilds: 'true' # -=- + MultiProcMaxCount: '3' # -=- + # C4152: nonstandard extension, function/data pointer conversion in expression + # C4201: nonstandard extension used: nameless struct/union + # C4310: cast truncates constant value + CFLAGS: /W4 /WX /wd4152 /wd4201 /wd4310 + CXXFLAGS: /W4 /WX + + steps: + - name: Cache Ninja install + if: matrix.GEN == 'Ninja Multi-Config' + id: ninja-install + uses: actions/cache@v4 + with: + path: | + C:\Tools\Ninja + key: ${{runner.os}}-ninja-${{env.NINJA_URL}} + + - name: Install Ninja + if: matrix.GEN == 'Ninja Multi-Config' && steps.ninja-install.outputs.cache-hit != 'true' + run: | + Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip + Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath ${env:NINJA_ROOT}\ + Remove-Item ~\Downloads\* + + - name: Checkout OpenCL-CLHPP + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-ICD-Loader + path: external/OpenCL-ICD-Loader + + - name: Build & install OpenCL-Headers (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build" ` + --target install ` + --config Release ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers failed." } + + - name: Build & install OpenCL-Headers (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build" ` + --target install ` + --config Release + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers failed." } + + - name: Build & install OpenCL-ICD-Loader (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install ` + -D CMAKE_PREFIX_PATH=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\build" ` + --target install ` + --config Release ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader failed." } + + - name: Build & install OpenCL-ICD-Loader (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install ` + -D CMAKE_PREFIX_PATH=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\build" ` + --target install ` + --config Release + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader failed." } + + - name: Configure (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=ON ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install" ` + -S ${env:GITHUB_WORKSPACE} ` + -B ${env:GITHUB_WORKSPACE}\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP failed." } + + - name: Configure (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=ON ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install" ` + -S ${env:GITHUB_WORKSPACE} ` + -B ${env:GITHUB_WORKSPACE}\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP failed." } + + - name: Build (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config ${Config} ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP in $Config failed." } + } + + - name: Build (Ninja) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP in $Config failed." } + } + + - name: Test + run: | + foreach ($Config in 'Release','Debug') { + & ctest ` + --test-dir "${env:GITHUB_WORKSPACE}\build" ` + --build-config ${Config} ` + --output-on-failure ` + --no-tests=error ` + --parallel ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "Testing OpenCL-CLHPP in $Config failed." } + } + + - name: Install + run: | + & cmake ` + --install "${env:GITHUB_WORKSPACE}\build" ` + --prefix "${env:GITHUB_WORKSPACE}\install" ` + --config Release + if ($LASTEXITCODE -ne 0) { throw "Installing OpenCL-CLHPP failed." } + + - name: "Consume (MSBuild standalone): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A ${BIN} ` + -T ${{matrix.VER}} ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install;${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP standalone consume test failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C ${Config} + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-CLHPP standalone consume test in $Config failed." } + } + + - name: "Consume (Ninja-Multi-Config standalone): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install;${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP standalone consume test failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C ${Config} + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-CLHPP standalone consume test in $Config failed." } + } + + - name: Consume (Emulate SDK presence) + run: | + New-Item -Type Directory -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL + $workspace = ${env:GITHUB_WORKSPACE}.replace("\", "/") + New-Item -Type File -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL\OpenCLConfig.cmake -Value "include(`"$workspace/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake`")`r`ninclude(`"$workspace/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake`")`r`ninclude(`"`${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake`")" + + - name: "Consume (MSBuild SDK): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A ${BIN} ` + -T ${{matrix.VER}} ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install;${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP in-SDK consume test failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C ${Config} + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-CLHPP in-SDK consume test in $Config failed." } + } + + - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=${VER}" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} ` + -D CMAKE_CXX_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\external\OpenCL-ICD-Loader\install;${env:GITHUB_WORKSPACE}\install" ` + -S "${env:GITHUB_WORKSPACE}\tests\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-CLHPP in-SDK consume test failed." } + foreach ($Config in 'Release','Debug') { ` + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config ${Config} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-CLHPP in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C ${Config} + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-CLHPP in-SDK consume test in $Config failed." } + } + + macos: + runs-on: macos-latest + defaults: + run: + shell: bash + strategy: + matrix: + COMPILER: + - C_NAME: /usr/bin/clang + CXX_NAME: /usr/bin/clang++ + # Disabled due to problems with __has_cpp_attribute + # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114007 + #- C_NAME: gcc-11 + # CXX_NAME: g++-11 + # Disabled due to problems with the __API_AVAILABLE macro + # - C_NAME: gcc-13 + # CXX_NAME: g++-13 + # # A workaround for a bug in the toolset + # # See https://forums.developer.apple.com/forums/thread/737707 + # EXTRA_FLAGS: -Wl,-ld_classic + GEN: + - Xcode + - Ninja Multi-Config + CXXSTD: [11, 17] + exclude: + # These entries are excluded, since XCode selects its own compiler + - COMPILER: + C_NAME: gcc-11 + CXX_NAME: g++-11 + GEN: Xcode + - COMPILER: + C_NAME: gcc-13 + CXX_NAME: g++-13 + GEN: Xcode + env: + CC: ${{matrix.COMPILER.C_NAME}} + CXX: ${{matrix.COMPILER.CXX_NAME}} + CFLAGS: -Wall -Wextra -pedantic -Wno-format -Werror ${{matrix.COMPILER.EXTRA_FLAGS}} + CXXFLAGS: -Wall -Wextra -pedantic -Wno-format -Werror ${{matrix.COMPILER.EXTRA_FLAGS}} + + steps: + - name: Checkout OpenCL-CLHPP + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-ICD-Loader + path: external/OpenCL-ICD-Loader + + - name: Create Build Environment + run: | + # Install Ninja only if it's the selected generator and it's not available. + if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi && + if [[ ! `which pkg-config` ]]; then brew install pkg-config; fi; + cmake --version + + - name: Build & install OpenCL-Headers + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=OFF + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + cmake + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + --config Release + --parallel `sysctl -n hw.logicalcpu` + + - name: Build & install OpenCL-ICD-Loader + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=OFF + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install + -S $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader + -B $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build && + cmake + --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build + --target install + --config Release + --parallel `sysctl -n hw.logicalcpu` + + - name: Configure + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=ON + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} + -D CMAKE_CXX_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: | + cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` + cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build + run: | + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + - name: Test install + run: | + cmake --build $GITHUB_WORKSPACE/build --config Release --target install + + - name: Consume (install) + run: cmake + -G "${{matrix.GEN}}" + -D CMAKE_CXX_STANDARD=${{matrix.CXXSTD}} + -D CMAKE_CXX_EXTENSIONS=OFF + -D CMAKE_CXX_STANDARD_REQUIRED=ON + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install;$GITHUB_WORKSPACE/install" + -S $GITHUB_WORKSPACE/tests/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + cmake --build $GITHUB_WORKSPACE/build_install --config Release --parallel `sysctl -n hw.logicalcpu` && + cmake --build $GITHUB_WORKSPACE/build_install --config Debug --parallel `sysctl -n hw.logicalcpu` && + cd $GITHUB_WORKSPACE/build_install && + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` && + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + - name: Test pkg-config + run: | + export PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/share/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install/lib/pkgconfig + pkg-config OpenCL-CLHPP --cflags | grep -q "\-I$GITHUB_WORKSPACE/install/include" + + - name: Test pkg-config dependency + run: | + export PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/share/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install/lib/pkgconfig + pkg-config OpenCL-CLHPP --cflags | grep -q "\-I$GITHUB_WORKSPACE/external/OpenCL-Headers/install/include" + + android: + runs-on: ubuntu-latest + defaults: + run: + shell: bash + strategy: + matrix: + ABI: + - arm64-v8a + - x86_64 + API_LEVEL: + - android-19 + - android-33 + CONFIG: + - Debug + - Release + env: + CFLAGS: -Wall -Wextra -pedantic -Werror + CXXFLAGS: -Wall -Wextra -pedantic -Werror + steps: + - name: Checkout OpenCL-CLHPP + uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-ICD-Loader + path: external/OpenCL-ICD-Loader + + - name: Configure & install OpenCL-Headers + run: cmake + -G "Unix Makefiles" + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D BUILD_TESTING=OFF + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + cmake + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + -- + -j`nproc` + + - name: Configure & install OpenCL-ICD-Loader + run: cmake + -G "Unix Makefiles" + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install + -D BUILD_TESTING=ON + -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake + -D ANDROID_ABI=${{matrix.ABI}} + -D ANDROID_PLATFORM=${{matrix.API_LEVEL}} + -D CMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY + -D CMAKE_FIND_ROOT_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -S $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader + -B $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build && + sudo cmake + --build $GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/build + --target install + -- + -j`nproc` + + - name: Configure + run: cmake + -G "Unix Makefiles" + -D BUILD_TESTING=ON + -D BUILD_EXAMPLES=ON + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake + -D ANDROID_ABI=${{matrix.ABI}} + -D ANDROID_PLATFORM=${{matrix.API_LEVEL}} + -D CMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY + -D CMAKE_FIND_ROOT_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/external/OpenCL-ICD-Loader/install" + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: cmake --build $GITHUB_WORKSPACE/build -j `nproc` diff --git a/deps/opencl-headers-hpp/.github/workflows/release.yml b/deps/opencl-headers-hpp/.github/workflows/release.yml new file mode 100644 index 000000000..a39d9b0de --- /dev/null +++ b/deps/opencl-headers-hpp/.github/workflows/release.yml @@ -0,0 +1,76 @@ +name: Release + +on: + push: + tags: + - "v*" +env: + distroseries: jammy + +jobs: + release: + if: false + runs-on: ubuntu-latest + defaults: + run: + shell: bash + steps: + - name: Add PPA + run: sudo add-apt-repository -y ppa:${{ vars.PPA }} + + - name: Install prerequisites + run: sudo apt-get update -qq && sudo apt-get install -y cmake devscripts debhelper-compat=13 opencl-c-headers doxygen + + - name: Import GPG signing key + run: echo "${{ secrets.DEB_SIGNING_KEY }}" | gpg --import + + - name: Download and extract source code + run: | + wget -O $GITHUB_WORKSPACE/source.orig.tar.gz https://github.com/$GITHUB_REPOSITORY/archive/refs/tags/$GITHUB_REF_NAME.tar.gz + tar -xvf $GITHUB_WORKSPACE/source.orig.tar.gz + + - name: Configure project out-of-tree + run: cmake + -S $GITHUB_WORKSPACE/OpenCL-CLHPP* + -B $GITHUB_WORKSPACE/../build + -D CMAKE_BUILD_TYPE=Release + -D CMAKE_INSTALL_PREFIX=/usr + -D BUILD_TESTING=OFF + -D BUILD_EXAMPLES=OFF + -D BUILD_DOCS=OFF + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D CPACK_DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + + - name: Generate packaging scripts + run: cmake + -D CMAKE_CACHE_PATH=$GITHUB_WORKSPACE/../build/CMakeCache.txt + -D ORIG_ARCHIVE=$GITHUB_WORKSPACE/source.orig.tar.gz + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D DEBIAN_DISTROSERIES=${{ env.distroseries }} + -D DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + -P $GITHUB_WORKSPACE/OpenCL-CLHPP*/cmake/DebSourcePkg.cmake + + - name: Build source package + run: | + cd $GITHUB_WORKSPACE/OpenCL-CLHPP*/ + debuild -S -sa + + - name: Build binary package + run: cpack + -G DEB + -C Release + -B $GITHUB_WORKSPACE/../build + --config $GITHUB_WORKSPACE/../build/CPackConfig.cmake + + # The following step does not depend on the previous step "Build binary package", + # but if the binary package build is unsuccessful, it is better not to push the + # source packages to the PPA + - name: Push source package to the PPA + run: dput ppa:${{ vars.PPA }} $GITHUB_WORKSPACE/*source.changes + + - name: Create GitHub release + uses: softprops/action-gh-release@v1 + with: + files: ${{ github.workspace }}/../build/*.deb diff --git a/deps/opencl-headers-hpp/.github/workflows/windows.yml b/deps/opencl-headers-hpp/.github/workflows/windows.yml deleted file mode 100644 index 6313030b5..000000000 --- a/deps/opencl-headers-hpp/.github/workflows/windows.yml +++ /dev/null @@ -1,213 +0,0 @@ -name: Windows - -on: [push, pull_request] - -jobs: - msvc: - runs-on: windows-2022 - strategy: - matrix: - VER: [v141, v142, v143] - EXT: [ON] # OFF: error C2079: 'statbuf' uses undefined struct 'stat' - GEN: [Visual Studio 17 2022, Ninja Multi-Config] - BIN: [x64, x86] - STD: [11, 17] - CMAKE: [3.22.0] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{matrix.CMAKE}}/cmake-${{matrix.CMAKE}}-windows-x86_64.zip - CMAKE_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\cmake.exe - CTEST_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\ctest.exe - NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip - NINJA_EXE: C:\Tools\Ninja\ninja.exe - - steps: - - name: Checkout OpenCL-CLHPP - uses: actions/checkout@v2 - with: - submodules: recursive - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-ICD-Loader - path: external/OpenCL-ICD-Loader - - - name: Create Build Environment - shell: pwsh - run: | - Invoke-WebRequest ${env:CMAKE_URL} -OutFile ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip - Expand-Archive ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip -DestinationPath C:\Tools\Kitware\CMake\ - Rename-Item C:\Tools\Kitware\CMake\* ${{matrix.CMAKE}} - Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip - Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath C:\Tools\Ninja\ - Remove-Item ~\Downloads\* - & ${env:CMAKE_EXE} --version - & ${env:NINJA_EXE} --version - - - name: Build & install OpenCL-Headers (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - set C_FLAGS="/w" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install --config Release -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build & install OpenCL-Headers (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - set C_FLAGS="/w" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install -- -j%NUMBER_OF_PROCESSORS% - - - name: Build & install OpenCL-ICD-Loader (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - set C_FLAGS="/w" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader -B %GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-ICD-Loader/build --target install --config Release -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build & install OpenCL-ICD-Loader (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - set C_FLAGS="/w" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader -B %GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-ICD-Loader/build --target install --config Release -- -j%NUMBER_OF_PROCESSORS% - - - name: Configure (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\install" -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Configure (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\external\OpenCL-ICD-Loader\install" -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Build (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release -- /verbosity:minimal /maxCpuCount /noLogo - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - if /I "${{matrix.VER}}"=="v140" set VER=14.0 - if /I "${{matrix.VER}}"=="v141" set VER=14.1 - if /I "${{matrix.VER}}"=="v142" set VER=14.2 - if /I "${{matrix.VER}}"=="v143" set VER=14.3 - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug - - - name: Test - continue-on-error: true - working-directory: ${{runner.workspace}}/OpenCL-CLHPP/build - shell: cmd - run: | - %CTEST_EXE% -C Release --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - %CTEST_EXE% -C Debug --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - - - name: Install - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/build --config Release --target install - - - name: "Consume (MSBuild standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (MSBuild SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("/home/runner/work/OpenCL-CLHPP/OpenCL-CLHPP/external/OpenCL-ICD-Loader/install/share/cmake/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/tests/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/tests/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug diff --git a/deps/opencl-headers-hpp/.gitignore b/deps/opencl-headers-hpp/.gitignore new file mode 100644 index 000000000..2ba69600f --- /dev/null +++ b/deps/opencl-headers-hpp/.gitignore @@ -0,0 +1,14 @@ +# Build dir +[Bb]uild/ + +# Install dir +[Ii]nstall/ + +# Package dir +[Pp]ackage[-_\s\d]*/ + +# External dir +[Ee]xternal/ + +# Visual Studio Code +.vscode diff --git a/deps/opencl-headers-hpp/.gitmodules b/deps/opencl-headers-hpp/.gitmodules index a57d2cb43..d51ccbfcf 100644 --- a/deps/opencl-headers-hpp/.gitmodules +++ b/deps/opencl-headers-hpp/.gitmodules @@ -1,6 +1,3 @@ [submodule "external/CMock"] path = external/CMock url = https://github.com/ThrowTheSwitch/CMock -[submodule "external/Unity"] - path = external/Unity - url = https://github.com/ThrowTheSwitch/Unity diff --git a/deps/opencl-headers-hpp/CMakeLists.txt b/deps/opencl-headers-hpp/CMakeLists.txt index 45a9f9374..138d3dde7 100644 --- a/deps/opencl-headers-hpp/CMakeLists.txt +++ b/deps/opencl-headers-hpp/CMakeLists.txt @@ -1,129 +1,133 @@ -cmake_minimum_required(VERSION 3.1) - -project(OpenCLHeadersCpp - VERSION 3.0 - LANGUAGES CXX # Ideally should be NONE, but GNUInstallDirs detects platform arch using try_compile - # https://stackoverflow.com/questions/43379311/why-does-project-affect-cmakes-opinion-on-cmake-sizeof-void-p -) -enable_testing() - -set(CMAKE_CXX_STANDARD 11) -set(CMAKE_CXX_STANDARD_REQUIRED ON) - -option(BUILD_DOCS "Build Documentation" ON) -option(BUILD_EXAMPLES "Build Examples" ON) -option(OPENCL_CLHPP_BUILD_TESTING "Enable support for OpenCL C++ headers testing." OFF) -set(THREADS_PREFER_PTHREAD_FLAG ON CACHE BOOL - "find_package(Threads) preference. Recommendation is to keep default value." -) -# Legacy helper variables, see later at finding headers and ICD Loader -set(OPENCL_DIST_DIR "" CACHE PATH "OpenCL source dir (legacy helper var)") -set(OPENCL_LIB_DIR "${OPENCL_DIST_DIR}/lib" CACHE PATH "OpenCL library dir (legacy helper var)" ) -set(OPENCL_INCLUDE_DIR "${OPENCL_DIST_DIR}/include" CACHE PATH "OpenCL source dir (legacy helper var)") -# Helper vars with names consistent with OpenCL-ICD-Loader's OPENCL_ICD_LOADER_HEADERS_DIR -# Default values taken from legacy defaults -set(OPENCL_CLHPP_HEADERS_DIR "${OPENCL_INCLUDE_DIR}" CACHE PATH "OpenCL headers dir") -set(OPENCL_CLHPP_LOADER_DIR "${OPENCL_LIB_DIR}" CACHE PATH "OpenCL library dir") - -add_library(HeadersCpp INTERFACE) -add_library(OpenCL::HeadersCpp ALIAS HeadersCpp) - -if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_CLHPP_BUILD_TESTING) - include(CTest) -endif() -if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_CLHPP_BUILD_TESTING) AND BUILD_TESTING) - set(CLHPP_BUILD_TESTS ON) -endif() - -# In the spirit of backward compatibility, to not break existing build automation -# we first check if the helper vars refer to existing files. If yes, use them. -# Otherwise search using 3.0 installed CMake Package Configs. -if(EXISTS "${OPENCL_CLHPP_HEADERS_DIR}/CL/cl.h") - if(NOT TARGET OpenCL::Headers) - message(STATUS "Defining OpenCL::Headers through OPENCL_INCLUDE_DIR") - add_library(OpenCLHeaders INTERFACE) - add_library(OpenCL::Headers ALIAS OpenCLHeaders) - target_include_directories(OpenCLHeaders INTERFACE ${OPENCL_INCLUDE_DIR}) - endif() -else() - if(NOT TARGET OpenCL::Headers) - find_package(OpenCLHeaders REQUIRED) - endif() -endif() -if(BUILD_EXAMPLES OR CLHPP_BUILD_TESTS) - enable_language(C) - find_package(Threads REQUIRED) -endif() -if(CLHPP_BUILD_TESTS) - find_program(RUBY_EXECUTABLE ruby REQUIRED) -endif() - -target_include_directories(HeadersCpp - INTERFACE - $ - $ -) -target_link_libraries(HeadersCpp - INTERFACE - OpenCL::Headers -) - -install( - TARGETS HeadersCpp - EXPORT OpenCLHeadersCppTargets -) - -include(GNUInstallDirs) - -install( - DIRECTORY include/CL - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} -) -export( - EXPORT OpenCLHeadersCppTargets - FILE ${PROJECT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake - NAMESPACE OpenCL:: -) -file( - WRITE ${PROJECT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfig.cmake - "include(\"\${CMAKE_CURRENT_LIST_DIR}/OpenCLHeadersCppTargets.cmake\")" -) - -set(config_package_location ${CMAKE_INSTALL_DATADIR}/cmake/OpenCLHeadersCpp) -install( - EXPORT OpenCLHeadersCppTargets - FILE OpenCLHeadersCppTargets.cmake - NAMESPACE OpenCL:: - DESTINATION ${config_package_location} -) -install( - FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfig.cmake - DESTINATION ${config_package_location} -) - -unset(CMAKE_SIZEOF_VOID_P) -include(CMakePackageConfigHelpers) -write_basic_package_version_file( - ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfigVersion.cmake - VERSION ${PROJECT_VERSION} - COMPATIBILITY AnyNewerVersion -) -install( - FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfigVersion.cmake - DESTINATION ${config_package_location} -) - -set(UNITY_DIR ${PROJECT_SOURCE_DIR}/external/Unity CACHE PATH "Unity dir") -set(CMOCK_DIR ${PROJECT_SOURCE_DIR}/external/CMock CACHE PATH "CMock dir") - -if(BUILD_DOCS) - add_subdirectory(docs) -endif(BUILD_DOCS) - -if(BUILD_EXAMPLES) - add_subdirectory(examples) -endif(BUILD_EXAMPLES) - -if(CLHPP_BUILD_TESTS) - add_subdirectory(tests) -endif(CLHPP_BUILD_TESTS) +cmake_minimum_required(VERSION 3.16) + +project(OpenCLHeadersCpp + VERSION 3.0 + LANGUAGES CXX # Ideally should be NONE, but GNUInstallDirs detects platform arch using try_compile + # https://stackoverflow.com/questions/43379311/why-does-project-affect-cmakes-opinion-on-cmake-sizeof-void-p +) +enable_testing() + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +option(BUILD_DOCS "Build Documentation" ON) +option(BUILD_EXAMPLES "Build Examples" ON) +option(OPENCL_CLHPP_BUILD_TESTING "Enable support for OpenCL C++ headers testing." OFF) +set(THREADS_PREFER_PTHREAD_FLAG ON CACHE BOOL + "find_package(Threads) preference. Recommendation is to keep default value." +) +# Legacy helper variables, see later at finding headers and ICD Loader +set(OPENCL_DIST_DIR "" CACHE PATH "OpenCL source dir (legacy helper var)") +set(OPENCL_LIB_DIR "${OPENCL_DIST_DIR}/lib" CACHE PATH "OpenCL library dir (legacy helper var)" ) +set(OPENCL_INCLUDE_DIR "${OPENCL_DIST_DIR}/include" CACHE PATH "OpenCL source dir (legacy helper var)") +# Helper vars with names consistent with OpenCL-ICD-Loader's OPENCL_ICD_LOADER_HEADERS_DIR +# Default values taken from legacy defaults +set(OPENCL_CLHPP_HEADERS_DIR "${OPENCL_INCLUDE_DIR}" CACHE PATH "OpenCL headers dir") +set(OPENCL_CLHPP_LOADER_DIR "${OPENCL_LIB_DIR}" CACHE PATH "OpenCL library dir") + +add_library(HeadersCpp INTERFACE) +add_library(OpenCL::HeadersCpp ALIAS HeadersCpp) + +if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_CLHPP_BUILD_TESTING) + include(CTest) +endif() +if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_CLHPP_BUILD_TESTING) AND BUILD_TESTING) + set(CLHPP_BUILD_TESTS ON) +endif() + +# In the spirit of backward compatibility, to not break existing build automation +# we first check if the helper vars refer to existing files. If yes, use them. +# Otherwise search using 3.0 installed CMake Package Configs. +if(EXISTS "${OPENCL_CLHPP_HEADERS_DIR}/CL/cl.h") + if(NOT TARGET OpenCL::Headers) + message(STATUS "Defining OpenCL::Headers through OPENCL_INCLUDE_DIR") + add_library(OpenCLHeaders INTERFACE) + add_library(OpenCL::Headers ALIAS OpenCLHeaders) + target_include_directories(OpenCLHeaders INTERFACE ${OPENCL_INCLUDE_DIR}) + endif() +else() + if(NOT TARGET OpenCL::Headers) + find_package(OpenCLHeaders REQUIRED) + endif() +endif() +if(BUILD_EXAMPLES OR CLHPP_BUILD_TESTS) + enable_language(C) + find_package(Threads REQUIRED) +endif() +if(CLHPP_BUILD_TESTS) + find_program(RUBY_EXECUTABLE ruby REQUIRED) +endif() + +target_include_directories(HeadersCpp + INTERFACE + $ + $ +) +target_link_libraries(HeadersCpp + INTERFACE + OpenCL::Headers +) + +install( + TARGETS HeadersCpp + EXPORT OpenCLHeadersCppTargets +) + +include(GNUInstallDirs) + +set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") +include(JoinPaths) +include(Package) + +install( + DIRECTORY include/CL + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} +) +export( + EXPORT OpenCLHeadersCppTargets + FILE ${PROJECT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppTargets.cmake + NAMESPACE OpenCL:: +) +file( + WRITE ${PROJECT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfig.cmake + "include(\"\${CMAKE_CURRENT_LIST_DIR}/OpenCLHeadersCppTargets.cmake\")" +) + +set(config_package_location ${CMAKE_INSTALL_DATADIR}/cmake/OpenCLHeadersCpp) +install( + EXPORT OpenCLHeadersCppTargets + FILE OpenCLHeadersCppTargets.cmake + NAMESPACE OpenCL:: + DESTINATION ${config_package_location} +) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfig.cmake + DESTINATION ${config_package_location} +) + +unset(CMAKE_SIZEOF_VOID_P) +include(CMakePackageConfigHelpers) +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion +) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLHeadersCpp/OpenCLHeadersCppConfigVersion.cmake + DESTINATION ${config_package_location} +) + +set(UNITY_DIR ${PROJECT_SOURCE_DIR}/external/CMock/vendor/unity CACHE PATH "Unity dir") +set(CMOCK_DIR ${PROJECT_SOURCE_DIR}/external/CMock CACHE PATH "CMock dir") + +if(BUILD_DOCS) + add_subdirectory(docs) +endif(BUILD_DOCS) + +if(BUILD_EXAMPLES) + add_subdirectory(examples) +endif(BUILD_EXAMPLES) + +if(CLHPP_BUILD_TESTS) + add_subdirectory(tests) +endif(CLHPP_BUILD_TESTS) diff --git a/deps/opencl-headers-hpp/OpenCL-CLHPP.pc.in b/deps/opencl-headers-hpp/OpenCL-CLHPP.pc.in new file mode 100644 index 000000000..5d4a07b91 --- /dev/null +++ b/deps/opencl-headers-hpp/OpenCL-CLHPP.pc.in @@ -0,0 +1,8 @@ +prefix=@PKGCONFIG_PREFIX@ +includedir=@OPENCLHPP_INCLUDEDIR_PC@ + +Name: OpenCL-CLHPP +Description: OpenCL API C++ bindings +Requires: OpenCL-Headers +Version: 3.0 +Cflags: -I${includedir} diff --git a/deps/opencl-headers-hpp/README.md b/deps/opencl-headers-hpp/README.md index a0cac6556..9268e6a2c 100644 --- a/deps/opencl-headers-hpp/README.md +++ b/deps/opencl-headers-hpp/README.md @@ -1,94 +1,94 @@ -# OpenCLTM API C++ bindings - -Doxgen documentation for the bindings is available here: - - http://khronosgroup.github.io/OpenCL-CLHPP/ - -Components: - - * `include/CL/opencl.hpp`: - The latest, maintained, version of the C++ bindings. It should work with all - versions of OpenCL (including 1.x). This is what most users will want. - - * `include/CL/cl2.hpp`: - Includes `opencl.hpp` and emits a warning, for backwards compability. - - * `docs`: - Doxygen file used to generate HTML documentation for `opencl.hpp`. - - * `examples`: - A simple example application using the very basic features of the bindings. - - * `tests`: - A (very small, incomplete) set of regression tests. Building the tests - requires Python, Ruby, Unity and CMock. For the last two we use - [Unity 2.1.0](https://github.com/ThrowTheSwitch/Unity/releases/tag/v2.1.0) - and [CMock top-of-tree from Github](https://github.com/ThrowTheSwitch/CMock) - (the version 2.0.204 on Sourceforge does not work). - - * `CMakeLists.txt`: - Build system for the examples and tests and logic for the bindings - installation. - -## Build Instructions - -> While the C++ Headers can be built and installed in isolation, it is part of the [OpenCL SDK](https://github.com/KhronosGroup/OpenCL-SDK). If looking for streamlined build experience and a complete development package, refer to the SDK build instructions instead of the following guide. - -### Dependencies - -The C++ Headers require: - -- the [OpenCL Headers](https://github.com/KhronosGroup/OpenCL-Headers/). - - It is recommended to install the headers via CMake, however a convenience shorthand is provided. Providing `OPENCL_CLHPP_HEADERS_DIR` to CMake, one may specify the location of OpenCL Headers. By default, the C++ Headers will look for OpenCL Headers under `${OPENCL_DIST_DIR}/include`. -- the [OpenCL-ICD-Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader/) when building the examples - - It is recommended to install the ICD loader via CMake, however a convenience shorthand is provided. Providing `OPENCL_CLHPP_LOADER_DIR` to CMake, one may specify the location of the OpenCL ICD loader. By default, the C++ headers will look for OpenCL ICD loader under `${OPENCL_DIST_DIR}/lib`. -- The C++ Headers uses CMake for its build system. -If CMake is not provided by your build system or OS package manager, please consult the [CMake website](https://cmake.org). -- The unit tests require [CMock](https://github.com/ThrowTheSwitch/CMock) and [Unity](https://github.com/ThrowTheSwitch/Unity). To get these external dependencies, use `--recursive` when cloning -the repository, or run `git submodule update --init --recursive`. -- Generating the mock input requires [Ruby](https://www.ruby-lang.org/en/). -- Generating the docs requires Doxygen. When it is available, you can generate HTML documentation by building the `docs` target. - -### Example Build - -1. Clone this repo, the OpenCL ICD Loader and the OpenCL Headers: - - git clone --recursive https://github.com/KhronosGroup/OpenCL-CLHPP - git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader - git clone https://github.com/KhronosGroup/OpenCL-Headers - -1. Install OpenCL Headers CMake package - - cmake -D CMAKE_INSTALL_PREFIX=./OpenCL-Headers/install -S ./OpenCL-Headers -B ./OpenCL-Headers/build - cmake --build ./OpenCL-Headers/build --target install - -1. Build and install OpenCL ICD Loader CMake package. _(Note that `CMAKE_PREFIX_PATH` need to be an absolute path. Update as needed.)_ - - cmake -D CMAKE_PREFIX_PATH=/absolute/path/to/OpenCL-Headers/install -D CMAKE_INSTALL_PREFIX=./OpenCL-ICD-Loader/install -S ./OpenCL-ICD-Loader -B ./OpenCL-ICD-Loader/build - cmake --build ./OpenCL-ICD-Loader/build --target install - -1. Build and install OpenCL C++ Headers CMake package. - - cmake -D CMAKE_PREFIX_PATH="/absolute/path/to/OpenCL-Headers/install;/absolute/path/to/OpenCL-ICD-Loader/install" -D CMAKE_INSTALL_PREFIX=./OpenCL-CLHPP/install -S ./OpenCL-CLHPP -B ./OpenCL-CLHPP/build - cmake --build ./OpenCL-CLHPP/build --target install - -### Example Use - -Example CMake invocation - -```bash -cmake -D CMAKE_PREFIX_PATH="/chosen/install/prefix/of/headers;/chosen/install/prefix/of/loader;/chosen/install/prefix/of/cppheaders" /path/to/opencl/app -``` - -and sample `CMakeLists.txt` - -```cmake -cmake_minimum_required(VERSION 3.0) -cmake_policy(VERSION 3.0...3.18.4) -project(proj) -add_executable(app main.cpp) -find_package(OpenCLHeaders REQUIRED) -find_package(OpenCLICDLoader REQUIRED) -find_package(OpenCLHeadersCpp REQUIRED) -target_link_libraries(app PRIVATE OpenCL::Headers OpenCL::OpenCL OpenCL::HeadersCpp) -``` \ No newline at end of file +# OpenCLTM API C++ bindings + +Doxgen documentation for the bindings is available here: + + http://khronosgroup.github.io/OpenCL-CLHPP/ + +Components: + + * `include/CL/opencl.hpp`: + The latest, maintained, version of the C++ bindings. It should work with all + versions of OpenCL (including 1.x). This is what most users will want. + + * `include/CL/cl2.hpp`: + Includes `opencl.hpp` and emits a warning, for backwards compability. + + * `docs`: + Doxygen file used to generate HTML documentation for `opencl.hpp`. + + * `examples`: + A simple example application using the very basic features of the bindings. + + * `tests`: + A (very small, incomplete) set of regression tests. Building the tests + requires Python, Ruby, and CMock. For the last one we use + [CMock top-of-tree from Github](https://github.com/ThrowTheSwitch/CMock), + as the latest (at the time this was written) released CMock version, + v2.5.3, has some issues. + + * `CMakeLists.txt`: + Build system for the examples and tests and logic for the bindings + installation. + +## Build Instructions + +> While the C++ Headers can be built and installed in isolation, it is part of the [OpenCL SDK](https://github.com/KhronosGroup/OpenCL-SDK). If looking for streamlined build experience and a complete development package, refer to the SDK build instructions instead of the following guide. + +### Dependencies + +The C++ Headers require: + +- the [OpenCL Headers](https://github.com/KhronosGroup/OpenCL-Headers/). + - It is recommended to install the headers via CMake, however a convenience shorthand is provided. Providing `OPENCL_CLHPP_HEADERS_DIR` to CMake, one may specify the location of OpenCL Headers. By default, the C++ Headers will look for OpenCL Headers under `${OPENCL_DIST_DIR}/include`. +- the [OpenCL-ICD-Loader](https://github.com/KhronosGroup/OpenCL-ICD-Loader/) when building the examples + - It is recommended to install the ICD loader via CMake, however a convenience shorthand is provided. Providing `OPENCL_CLHPP_LOADER_DIR` to CMake, one may specify the location of the OpenCL ICD loader. By default, the C++ headers will look for OpenCL ICD loader under `${OPENCL_DIST_DIR}/lib`. +- The C++ Headers uses CMake for its build system. +If CMake is not provided by your build system or OS package manager, please consult the [CMake website](https://cmake.org). +- The unit tests require [CMock](https://github.com/ThrowTheSwitch/CMock). To get this external dependency, use `--recursive` when cloning +the repository, or run `git submodule update --init --recursive`. +- Generating the mock input requires [Ruby](https://www.ruby-lang.org/en/). +- Generating the docs requires Doxygen. When it is available, you can generate HTML documentation by building the `docs` target. + +### Example Build + +1. Clone this repo, the OpenCL ICD Loader and the OpenCL Headers: + + git clone --recursive https://github.com/KhronosGroup/OpenCL-CLHPP + git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader + git clone https://github.com/KhronosGroup/OpenCL-Headers + +1. Install OpenCL Headers CMake package + + cmake -D CMAKE_INSTALL_PREFIX=./OpenCL-Headers/install -S ./OpenCL-Headers -B ./OpenCL-Headers/build + cmake --build ./OpenCL-Headers/build --target install + +1. Build and install OpenCL ICD Loader CMake package. _(Note that `CMAKE_PREFIX_PATH` need to be an absolute path. Update as needed.)_ + + cmake -D CMAKE_PREFIX_PATH=/absolute/path/to/OpenCL-Headers/install -D CMAKE_INSTALL_PREFIX=./OpenCL-ICD-Loader/install -S ./OpenCL-ICD-Loader -B ./OpenCL-ICD-Loader/build + cmake --build ./OpenCL-ICD-Loader/build --target install + +1. Build and install OpenCL C++ Headers CMake package. + + cmake -D CMAKE_PREFIX_PATH="/absolute/path/to/OpenCL-Headers/install;/absolute/path/to/OpenCL-ICD-Loader/install" -D CMAKE_INSTALL_PREFIX=./OpenCL-CLHPP/install -S ./OpenCL-CLHPP -B ./OpenCL-CLHPP/build + cmake --build ./OpenCL-CLHPP/build --target install + +### Example Use + +Example CMake invocation + +```bash +cmake -D CMAKE_PREFIX_PATH="/chosen/install/prefix/of/headers;/chosen/install/prefix/of/loader;/chosen/install/prefix/of/cppheaders" /path/to/opencl/app +``` + +and sample `CMakeLists.txt` + +```cmake +cmake_minimum_required(VERSION 3.0) +cmake_policy(VERSION 3.0...3.18.4) +project(proj) +add_executable(app main.cpp) +find_package(OpenCLHeaders REQUIRED) +find_package(OpenCLICDLoader REQUIRED) +find_package(OpenCLHeadersCpp REQUIRED) +target_link_libraries(app PRIVATE OpenCL::Headers OpenCL::OpenCL OpenCL::HeadersCpp) +``` diff --git a/deps/opencl-headers-hpp/cmake/DebSourcePkg.cmake b/deps/opencl-headers-hpp/cmake/DebSourcePkg.cmake new file mode 100644 index 000000000..556ded4d3 --- /dev/null +++ b/deps/opencl-headers-hpp/cmake/DebSourcePkg.cmake @@ -0,0 +1,151 @@ +# This script produces the changelog, control and rules file in the debian +# directory. These files are needed to build a Debian source package from the repository. +# Run this in CMake script mode, e.g. +# $ cd OpenCL-CLHPP +# $ cmake -S . -B ../build -D BUILD_TESTING=OFF -D BUILD_EXAMPLES=OFF -D BUILD_DOCS=OFF +# $ cmake +# -DCMAKE_CACHE_PATH=../build/CMakeCache.txt +# -DCPACK_DEBIAN_PACKAGE_MAINTAINER="Example Name " +# -DDEBIAN_DISTROSERIES=jammy +# -DORIG_ARCHIVE=../OpenCL-Headers.tar.gz +# -DLATEST_RELEASE_VERSION=v2023.08.29 +# -P cmake/DebSourcePkg.cmake +# $ debuild -S -sa + +cmake_minimum_required(VERSION 3.21) # file(COPY_FILE) is added in CMake 3.21 + +set(DEB_SOURCE_PKG_NAME "khronos-opencl-clhpp") +set(DEB_C_HEADERS_PKG_NAME "opencl-c-headers") +set(DEB_META_PKG_NAME "opencl-headers") +set(DEB_DOC_PKG_NAME "opencl-clhpp-headers-doc") +set(DEB_DOC_PKG_DESCRIPTION "documentation for C++ OpenCL headers + OpenCL (Open Computing Language) is a multi-vendor open standard for + general-purpose parallel programming of heterogeneous systems that include + CPUs, GPUs and other processors. + . + This package provides the documentation of the C++ development header files + for the OpenCL API as published by The Khronos Group Inc. +") + +if(NOT EXISTS "${CMAKE_CACHE_PATH}") + message(FATAL_ERROR "CMAKE_CACHE_PATH is not set or does not exist") +endif() +if(NOT DEFINED DEBIAN_PACKAGE_MAINTAINER) + message(FATAL_ERROR "DEBIAN_PACKAGE_MAINTAINER is not set") +endif() +if(NOT DEFINED DEBIAN_DISTROSERIES) + message(FATAL_ERROR "DEBIAN_DISTROSERIES is not set") +endif() +if(NOT DEFINED ORIG_ARCHIVE) + message(WARNING "ORIG_ARCHIVE is not set") +elseif(NOT EXISTS "${ORIG_ARCHIVE}") + message(FATAL_ERROR "ORIG_ARCHIVE is defined, but the file does not exist at \"${ORIG_ARCHIVE}\"") +endif() +if(NOT DEFINED LATEST_RELEASE_VERSION) + message(WARNING "LATEST_RELEASE_VERSION is not set") +endif() +if(NOT DEFINED DEBIAN_VERSION_SUFFIX) + message(WARNING "DEBIAN_VERSION_SUFFIX is not set") +endif() + +# Extracting the project version from the main CMakeLists.txt via regex +file(READ "${CMAKE_CACHE_PATH}" CMAKE_CACHE) +string(REGEX MATCH "CMAKE_PROJECT_VERSION[^=]*=([^\n]*)" REGEX_MATCH "${CMAKE_CACHE}") +if(NOT REGEX_MATCH) + message(FATAL_ERROR "Could not extract project version from CMakeLists.txt") +endif() +set(PROJECT_VERSION "${CMAKE_MATCH_1}") + +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}") +# PackageSetup.cmake contains details for packaging +include(PackageSetup) + +# Append a space after every newline in the description. This format is required +# in the control file. +string(REPLACE "\n" "\n " CPACK_PACKAGE_DESCRIPTION "${CPACK_PACKAGE_DESCRIPTION}") + +set(DEB_SOURCE_PKG_DIR "${CMAKE_CURRENT_LIST_DIR}/../debian") +# Write debian/control +file(WRITE "${DEB_SOURCE_PKG_DIR}/control" +"Source: ${DEB_SOURCE_PKG_NAME} +Section: ${CPACK_DEBIAN_PACKAGE_SECTION} +Priority: optional +Maintainer: ${DEBIAN_PACKAGE_MAINTAINER} +Build-Depends: cmake, debhelper-compat (=13), doxygen, ${CPACK_DEBIAN_PACKAGE_DEPENDS} +Rules-Requires-Root: no +Homepage: ${CPACK_DEBIAN_PACKAGE_HOMEPAGE} +Standards-Version: 4.6.2 + +Package: ${DEBIAN_PACKAGE_NAME} +Architecture: ${CPACK_DEBIAN_PACKAGE_ARCHITECTURE} +Multi-Arch: foreign +Depends: ${CPACK_DEBIAN_PACKAGE_DEPENDS} +Breaks: ${CPACK_DEBIAN_PACKAGE_BREAKS} +Replaces: ${CPACK_DEBIAN_PACKAGE_REPLACES} +Description: ${CPACK_PACKAGE_DESCRIPTION} + +Package: ${DEB_DOC_PKG_NAME} +Section: doc +Architecture: all +Multi-Arch: foreign +Description: ${DEB_DOC_PKG_DESCRIPTION} +" +) +# Write debian/changelog +string(TIMESTAMP CURRENT_TIMESTAMP "%a, %d %b %Y %H:%M:%S +0000" UTC) +file(WRITE "${DEB_SOURCE_PKG_DIR}/changelog" +"${DEB_SOURCE_PKG_NAME} (${PACKAGE_VERSION_REVISION}) ${DEBIAN_DISTROSERIES}; urgency=medium + + * Released version ${PACKAGE_VERSION_REVISION} + + -- ${DEBIAN_PACKAGE_MAINTAINER} ${CURRENT_TIMESTAMP} +") +# Write debian/rules +file(WRITE "${DEB_SOURCE_PKG_DIR}/rules" +"#!/usr/bin/make -f +%: +\tdh $@ + +override_dh_auto_configure: +\tdh_auto_configure -- -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF -DBUILD_EXAMPLES=OFF + +override_dh_auto_build: +\tdh_auto_build -- all docs +") +# Write installed file list for headers package +file(WRITE "${DEB_SOURCE_PKG_DIR}/${DEBIAN_PACKAGE_NAME}.install" +"usr/include +usr/share +" +) +# Write installed file list for docs package +file(WRITE "${DEB_SOURCE_PKG_DIR}/${DEB_DOC_PKG_NAME}.install" +"obj-*/docs/html usr/share/doc/opencl-clhpp-headers/ +" +) +# Write doc base file +file(WRITE "${DEB_SOURCE_PKG_DIR}/${DEB_DOC_PKG_NAME}.doc-base" +"Document: ${DEBIAN_PACKAGE_NAME} +Title: OpenCL C++ Bindings Documentation +Author: The Khronos Group Inc. +Abstract: This manual describes the OpenCL C++ Bindings + as provided by The Khronos Group Inc. +Section: Programming/C++ + +Format: HTML +Index: /usr/share/doc/${DEBIAN_PACKAGE_NAME}/html/index.html +Files: /usr/share/doc/${DEBIAN_PACKAGE_NAME}/html/*.html +") + +if(DEFINED ORIG_ARCHIVE) + # Copy the passed orig.tar.gz file. The target filename is deduced from the version number, as expected by debuild + cmake_path(IS_ABSOLUTE ORIG_ARCHIVE IS_ORIG_ARCHIVE_ABSOLUTE) + if (NOT IS_ORIG_ARCHIVE_ABSOLUTE) + message(FATAL_ERROR "ORIG_ARCHIVE must be an absolute path (passed: \"${ORIG_ARCHIVE}\")") + endif() + cmake_path(GET ORIG_ARCHIVE EXTENSION ORIG_ARCHIVE_EXT) + cmake_path(GET ORIG_ARCHIVE PARENT_PATH ORIG_ARCHIVE_PARENT) + set(TARGET_PATH "${ORIG_ARCHIVE_PARENT}/${DEB_SOURCE_PKG_NAME}_${CPACK_DEBIAN_PACKAGE_VERSION}${ORIG_ARCHIVE_EXT}") + message(STATUS "Copying \"${ORIG_ARCHIVE}\" to \"${TARGET_PATH}\"") + file(COPY_FILE "${ORIG_ARCHIVE}" "${TARGET_PATH}") +endif() diff --git a/deps/opencl-headers-hpp/cmake/JoinPaths.cmake b/deps/opencl-headers-hpp/cmake/JoinPaths.cmake new file mode 100644 index 000000000..32d6d6685 --- /dev/null +++ b/deps/opencl-headers-hpp/cmake/JoinPaths.cmake @@ -0,0 +1,26 @@ +# This module provides function for joining paths +# known from from most languages +# +# Original license: +# SPDX-License-Identifier: (MIT OR CC0-1.0) +# Explicit permission given to distribute this module under +# the terms of the project as described in /LICENSE.rst. +# Copyright 2020 Jan Tojnar +# https://github.com/jtojnar/cmake-snips +# +# Modelled after Python’s os.path.join +# https://docs.python.org/3.7/library/os.path.html#os.path.join +# Windows not supported +function(join_paths joined_path first_path_segment) + set(temp_path "${first_path_segment}") + foreach(current_segment IN LISTS ARGN) + if(NOT ("${current_segment}" STREQUAL "")) + if(IS_ABSOLUTE "${current_segment}") + set(temp_path "${current_segment}") + else() + set(temp_path "${temp_path}/${current_segment}") + endif() + endif() + endforeach() + set(${joined_path} "${temp_path}" PARENT_SCOPE) +endfunction() diff --git a/deps/opencl-headers-hpp/cmake/Package.cmake b/deps/opencl-headers-hpp/cmake/Package.cmake new file mode 100644 index 000000000..5b8a34e42 --- /dev/null +++ b/deps/opencl-headers-hpp/cmake/Package.cmake @@ -0,0 +1,47 @@ +include("${CMAKE_CURRENT_LIST_DIR}/PackageSetup.cmake") + +# Configuring pkgconfig + +# We need two different instances of OpenCL.pc +# One for installing (cmake --install), which contains CMAKE_INSTALL_PREFIX as prefix +# And another for the Debian development package, which contains CPACK_PACKAGING_INSTALL_PREFIX as prefix + +join_paths(OPENCLHPP_INCLUDEDIR_PC "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + +set(pkg_config_location ${CMAKE_INSTALL_DATADIR}/pkgconfig) +set(PKGCONFIG_PREFIX "${CMAKE_INSTALL_PREFIX}") +configure_file( + OpenCL-CLHPP.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL-CLHPP.pc + @ONLY) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL-CLHPP.pc + DESTINATION ${pkg_config_location} + COMPONENT pkgconfig_install) + +set(PKGCONFIG_PREFIX "${CPACK_PACKAGING_INSTALL_PREFIX}") +configure_file( + OpenCL-CLHPP.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL-CLHPP.pc + @ONLY) +# This install component is only needed in the Debian package +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL-CLHPP.pc + DESTINATION ${pkg_config_location} + COMPONENT pkgconfig_package + EXCLUDE_FROM_ALL) + +# By using component based packaging, component pkgconfig_install +# can be excluded from the package, and component pkgconfig_package +# can be included. +set(CPACK_DEB_COMPONENT_INSTALL ON) +set(CPACK_COMPONENTS_GROUPING "ALL_COMPONENTS_IN_ONE") + +include(CPackComponent) +cpack_add_component(pkgconfig_install) +cpack_add_component(pkgconfig_package) +set(CPACK_COMPONENTS_ALL "Unspecified;pkgconfig_package") + +set(CPACK_DEBIAN_PACKAGE_DEBUG ON) + +include(CPack) diff --git a/deps/opencl-headers-hpp/cmake/PackageSetup.cmake b/deps/opencl-headers-hpp/cmake/PackageSetup.cmake new file mode 100644 index 000000000..eeee21b3a --- /dev/null +++ b/deps/opencl-headers-hpp/cmake/PackageSetup.cmake @@ -0,0 +1,56 @@ +set(CPACK_PACKAGE_VENDOR "khronos") + +set(CPACK_PACKAGE_DESCRIPTION "C++ headers for OpenCL development +C++ headers for OpenCL development +OpenCL (Open Computing Language) is a multi-vendor open standard for +general-purpose parallel programming of heterogeneous systems that include +CPUs, GPUs and other processors. +. +This package provides the C++ development header files for the OpenCL API +as published by The Khronos Group Inc. The corresponding specification and +documentation can be found on the Khronos website.") + +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt") + +set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md") + +if(NOT CPACK_PACKAGING_INSTALL_PREFIX) + set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") +endif() + +# DEB packaging configuration +set(CPACK_DEBIAN_PACKAGE_MAINTAINER ${CPACK_PACKAGE_VENDOR}) + +set(CPACK_DEBIAN_PACKAGE_HOMEPAGE + "https://github.com/KhronosGroup/OpenCL-CLHPP") + +set(CPACK_DEBIAN_PACKAGE_VERSION "${PROJECT_VERSION}") +if(DEFINED LATEST_RELEASE_VERSION) + # Remove leading "v", if exists + string(LENGTH "${LATEST_RELEASE_VERSION}" LATEST_RELEASE_VERSION_LENGTH) + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 0 1 LATEST_RELEASE_VERSION_FRONT) + if(LATEST_RELEASE_VERSION_FRONT STREQUAL "v") + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 1 ${LATEST_RELEASE_VERSION_LENGTH} LATEST_RELEASE_VERSION) + endif() + + string(APPEND CPACK_DEBIAN_PACKAGE_VERSION "~${LATEST_RELEASE_VERSION}") +endif() +set(CPACK_DEBIAN_PACKAGE_RELEASE "1") # debian_revision (because this is a non-native pkg) +set(PACKAGE_VERSION_REVISION "${CPACK_DEBIAN_PACKAGE_VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}${DEBIAN_VERSION_SUFFIX}") + +set(DEBIAN_PACKAGE_NAME "opencl-clhpp-headers") +set(CPACK_DEBIAN_PACKAGE_NAME + "${DEBIAN_PACKAGE_NAME}" + CACHE STRING "Package name" FORCE) + +set(CPACK_DEBIAN_PACKAGE_SECTION "libdevel") +set(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "all") + +# Dependencies +set(CPACK_DEBIAN_PACKAGE_DEPENDS "opencl-c-headers (>= ${CPACK_DEBIAN_PACKAGE_VERSION})") +set(CPACK_DEBIAN_PACKAGE_BREAKS "opencl-headers (<< ${CPACK_DEBIAN_PACKAGE_VERSION})") +set(CPACK_DEBIAN_PACKAGE_REPLACES "opencl-headers (<< ${CPACK_DEBIAN_PACKAGE_VERSION})") + +# Package file name in deb format: +# _-_.deb +set(CPACK_DEBIAN_FILE_NAME "${DEBIAN_PACKAGE_NAME}_${PACKAGE_VERSION_REVISION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb") diff --git a/deps/opencl-headers-hpp/examples/CMakeLists.txt b/deps/opencl-headers-hpp/examples/CMakeLists.txt index fa832a1fe..27e4941e9 100644 --- a/deps/opencl-headers-hpp/examples/CMakeLists.txt +++ b/deps/opencl-headers-hpp/examples/CMakeLists.txt @@ -1,3 +1 @@ -cmake_minimum_required(VERSION 3.0) - -add_subdirectory(src) +add_subdirectory(src) diff --git a/deps/opencl-headers-hpp/examples/src/CMakeLists.txt b/deps/opencl-headers-hpp/examples/src/CMakeLists.txt index c7c4be7ef..721a7644a 100644 --- a/deps/opencl-headers-hpp/examples/src/CMakeLists.txt +++ b/deps/opencl-headers-hpp/examples/src/CMakeLists.txt @@ -1,32 +1,32 @@ -file(GLOB OPENCL_LIBS_IN_LIB_DIR "${OPENCL_CLHPP_LOADER_DIR}/*OpenCL*") -if(NOT "${OPENCL_LIBS_IN_LIB_DIR}" STREQUAL "") - if(NOT TARGET OpenCL) - message(STATUS "Adding flags to CLHPP examples as per OPENCL_LIB_DIR") - link_directories("${OPENCL_LIB_DIR}") - else() - message(WARNING "User-provided OpenCL library found in ${OPENCL_LIB_DIR}. Cannot use it because the target \"OpenCL\" already exists in the build.") - endif() -else() - if(NOT TARGET OpenCL::OpenCL) - find_package(OpenCLICDLoader REQUIRED) - endif() -endif() - -foreach(EXAMPLE IN ITEMS - trivial - trivialSizeTCompat - headerexample -) - add_executable(${EXAMPLE} ${EXAMPLE}.cpp) - target_link_libraries(${EXAMPLE} - PRIVATE - OpenCL::HeadersCpp - OpenCL::Headers - Threads::Threads - ) - if(NOT "${OPENCL_LIBS_IN_LIB_DIR}" STREQUAL "") - target_link_libraries(${EXAMPLE} PRIVATE OpenCL) - else() - target_link_libraries(${EXAMPLE} PRIVATE OpenCL::OpenCL) - endif() -endforeach() +file(GLOB OPENCL_LIBS_IN_LIB_DIR "${OPENCL_CLHPP_LOADER_DIR}/*OpenCL*") +if(NOT "${OPENCL_LIBS_IN_LIB_DIR}" STREQUAL "") + if(NOT TARGET OpenCL) + message(STATUS "Adding flags to CLHPP examples as per OPENCL_LIB_DIR") + link_directories("${OPENCL_LIB_DIR}") + else() + message(WARNING "User-provided OpenCL library found in ${OPENCL_LIB_DIR}. Cannot use it because the target \"OpenCL\" already exists in the build.") + endif() +else() + if(NOT TARGET OpenCL::OpenCL) + find_package(OpenCLICDLoader REQUIRED) + endif() +endif() + +foreach(EXAMPLE IN ITEMS + trivial + trivialSizeTCompat + headerexample +) + add_executable(${EXAMPLE} ${EXAMPLE}.cpp) + target_link_libraries(${EXAMPLE} + PRIVATE + OpenCL::HeadersCpp + OpenCL::Headers + Threads::Threads + ) + if(NOT "${OPENCL_LIBS_IN_LIB_DIR}" STREQUAL "") + target_link_libraries(${EXAMPLE} PRIVATE OpenCL) + else() + target_link_libraries(${EXAMPLE} PRIVATE OpenCL::OpenCL) + endif() +endforeach() diff --git a/deps/opencl-headers-hpp/examples/src/headerexample.cpp b/deps/opencl-headers-hpp/examples/src/headerexample.cpp index b2c21b642..f1b3f838c 100644 --- a/deps/opencl-headers-hpp/examples/src/headerexample.cpp +++ b/deps/opencl-headers-hpp/examples/src/headerexample.cpp @@ -115,7 +115,7 @@ int main(void) // Traditional cl_mem allocations std::vector output(numElements, 0xdeadbeef); - cl::Buffer outputBuffer(begin(output), end(output), false); + cl::Buffer outputBuffer(output.begin(), output.end(), false); cl::Pipe aPipe(sizeof(cl_int), numElements / 2); // Default command queue, also passed in as a parameter @@ -152,7 +152,7 @@ int main(void) error ); - cl::copy(outputBuffer, begin(output), end(output)); + cl::copy(outputBuffer, output.begin(), output.end()); cl::Device d = cl::Device::getDefault(); diff --git a/deps/opencl-headers-hpp/examples/src/trivial.cpp b/deps/opencl-headers-hpp/examples/src/trivial.cpp index e44ad1d74..a7ef22800 100644 --- a/deps/opencl-headers-hpp/examples/src/trivial.cpp +++ b/deps/opencl-headers-hpp/examples/src/trivial.cpp @@ -167,7 +167,7 @@ int main(void) // Traditional cl_mem allocations std::vector output(numElements, 0xdeadbeef); - cl::Buffer outputBuffer(begin(output), end(output), false); + cl::Buffer outputBuffer(output.begin(), output.end(), false); std::vector>> output2(numElements / 2, 0xdeadbeef); cl::Pipe aPipe(sizeof(cl_int), numElements / 2); @@ -222,7 +222,7 @@ int main(void) ); // Copy the cl_mem output back to the vector - cl::copy(outputBuffer, begin(output), end(output)); + cl::copy(outputBuffer, output.begin(), output.end()); // Grab the SVM output vector using a map cl::mapSVM(output2); diff --git a/deps/opencl-headers-hpp/examples/src/trivialSizeTCompat.cpp b/deps/opencl-headers-hpp/examples/src/trivialSizeTCompat.cpp index 1a3e93ada..84435b366 100644 --- a/deps/opencl-headers-hpp/examples/src/trivialSizeTCompat.cpp +++ b/deps/opencl-headers-hpp/examples/src/trivialSizeTCompat.cpp @@ -75,9 +75,9 @@ int main(void) std::vector inputA(numElements, 1); std::vector inputB(numElements, 2); std::vector output(numElements, 0xdeadbeef); - cl::Buffer inputABuffer(begin(inputA), end(inputA), true); - cl::Buffer inputBBuffer(begin(inputB), end(inputB), true); - cl::Buffer outputBuffer(begin(output), end(output), false); + cl::Buffer inputABuffer(inputA.begin(), inputA.end(), true); + cl::Buffer inputBBuffer(inputB.begin(), inputB.end(), true); + cl::Buffer outputBuffer(output.begin(), output.end(), false); cl::Pipe aPipe(sizeof(cl_int), numElements / 2); // Unfortunately, there is no way to check for a default or know if a kernel needs one // so the user has to create one @@ -112,7 +112,7 @@ int main(void) cl::size_t<3> WGSizeResult = vectorAddKernel.getKernel().getWorkGroupInfo(cl::Device::getDefault()); std::cout << "Size_t return: " << WGSizeResult[0] << ", " << WGSizeResult[1] << ", " << WGSizeResult[2] << "\n"; - cl::copy(outputBuffer, begin(output), end(output)); + cl::copy(outputBuffer, output.begin(), output.end()); cl::Device d = cl::Device::getDefault(); std::cout << "Max pipe args: " << d.getInfo() << "\n"; diff --git a/deps/opencl-headers-hpp/include/CL/opencl.hpp b/deps/opencl-headers-hpp/include/CL/opencl.hpp index 1b2ef4ad9..600d5f7cd 100644 --- a/deps/opencl-headers-hpp/include/CL/opencl.hpp +++ b/deps/opencl-headers-hpp/include/CL/opencl.hpp @@ -1,5 +1,5 @@ // -// Copyright (c) 2008-2020 The Khronos Group Inc. +// Copyright (c) 2008-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,14 +33,12 @@ * * Optional extension support * - * cl_ext_device_fission - * #define CL_HPP_USE_CL_DEVICE_FISSION * cl_khr_d3d10_sharing * #define CL_HPP_USE_DX_INTEROP + * cl_khr_il_program + * #define CL_HPP_USE_IL_KHR * cl_khr_sub_groups * #define CL_HPP_USE_CL_SUB_GROUPS_KHR - * cl_khr_image2d_from_buffer - * #define CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR * * Doxygen documentation for this header is available here: * @@ -82,9 +80,9 @@ * * The combination of preprocessor macros CL_HPP_TARGET_OPENCL_VERSION and * CL_HPP_MINIMUM_OPENCL_VERSION control this range. These are three digit - * decimal values representing OpenCL runime versions. The default for - * the target is 200, representing OpenCL 2.0 and the minimum is also - * defined as 200. These settings would use 2.0 API calls only. + * decimal values representing OpenCL runtime versions. The default for + * the target is 300, representing OpenCL 3.0. The minimum is defined as 200. + * These settings would use 2.0 and newer API calls only. * If backward compatibility with a 1.2 runtime is required, the minimum * version may be set to 120. * @@ -139,6 +137,11 @@ * - CL_HPP_TARGET_OPENCL_VERSION * * Defines the target OpenCL runtime version to build the header + * against. Defaults to 300, representing OpenCL 3.0. + * + * - CL_HPP_MINIMUM_OPENCL_VERSION + * + * Defines the minimum OpenCL runtime version to build the header * against. Defaults to 200, representing OpenCL 2.0. * * - CL_HPP_NO_STD_STRING @@ -190,13 +193,6 @@ * applies to use of cl::Program construction and other program * build variants. * - * - CL_HPP_USE_CL_DEVICE_FISSION - * - * Enable the cl_ext_device_fission extension. - * - * - CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR - * - * Enable the cl_khr_image2d_from_buffer extension. * * - CL_HPP_USE_CL_SUB_GROUPS_KHR * @@ -340,7 +336,7 @@ // Traditional cl_mem allocations std::vector output(numElements, 0xdeadbeef); - cl::Buffer outputBuffer(begin(output), end(output), false); + cl::Buffer outputBuffer(output.begin(), output.end(), false); cl::Pipe aPipe(sizeof(cl_int), numElements / 2); // Default command queue, also passed in as a parameter @@ -377,7 +373,7 @@ error ); - cl::copy(outputBuffer, begin(output), end(output)); + cl::copy(outputBuffer, output.begin(), output.end()); cl::Device d = cl::Device::getDefault(); @@ -404,10 +400,6 @@ # pragma message("opencl.hpp: USE_DX_INTEROP is deprecated. Define CL_HPP_USE_DX_INTEROP instead") # define CL_HPP_USE_DX_INTEROP #endif -#if !defined(CL_HPP_USE_CL_DEVICE_FISSION) && defined(USE_CL_DEVICE_FISSION) -# pragma message("opencl.hpp: USE_CL_DEVICE_FISSION is deprecated. Define CL_HPP_USE_CL_DEVICE_FISSION instead") -# define CL_HPP_USE_CL_DEVICE_FISSION -#endif #if !defined(CL_HPP_ENABLE_EXCEPTIONS) && defined(__CL_ENABLE_EXCEPTIONS) # pragma message("opencl.hpp: __CL_ENABLE_EXCEPTIONS is deprecated. Define CL_HPP_ENABLE_EXCEPTIONS instead") # define CL_HPP_ENABLE_EXCEPTIONS @@ -527,23 +519,12 @@ #error Visual studio 2013 or another C++11-supporting compiler required #endif -// -#if defined(CL_HPP_USE_CL_DEVICE_FISSION) || defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) -#include -#endif - #if defined(__APPLE__) || defined(__MACOSX) #include #else #include #endif // !__APPLE__ -#if (__cplusplus >= 201103L || _MSVC_LANG >= 201103L ) -#define CL_HPP_NOEXCEPT_ noexcept -#else -#define CL_HPP_NOEXCEPT_ -#endif - #if __cplusplus >= 201703L # define CL_HPP_DEFINE_STATIC_MEMBER_ inline #elif defined(_MSC_VER) @@ -718,24 +699,27 @@ namespace cl { * */ namespace cl { - class Memory; -#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name) \ - if (!pfn_##name) { \ - pfn_##name = (PFN_##name) \ - clGetExtensionFunctionAddress(#name); \ - if (!pfn_##name) { \ - } \ +#define CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(name) \ + using PFN_##name = name##_fn + +#define CL_HPP_INIT_CL_EXT_FCN_PTR_(name) \ + if (!pfn_##name) { \ + pfn_##name = (PFN_##name)clGetExtensionFunctionAddress(#name); \ } -#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name) \ - if (!pfn_##name) { \ - pfn_##name = (PFN_##name) \ - clGetExtensionFunctionAddressForPlatform(platform, #name); \ - if (!pfn_##name) { \ - } \ +#define CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, name) \ + if (!pfn_##name) { \ + pfn_##name = (PFN_##name) \ + clGetExtensionFunctionAddressForPlatform(platform, #name); \ } +#ifdef cl_khr_external_memory + enum class ExternalMemoryType : cl_external_memory_handle_type_khr; +#endif + + class Memory; + class Platform; class Program; class Device; class Context; @@ -744,6 +728,13 @@ namespace cl { class Memory; class Buffer; class Pipe; +#ifdef cl_khr_semaphore + class Semaphore; +#endif +#if defined(cl_khr_command_buffer) + class CommandBufferKhr; + class MutableCommandKhr; +#endif // cl_khr_command_buffer #if defined(CL_HPP_ENABLE_EXCEPTIONS) /*! \brief Exception class @@ -765,18 +756,16 @@ namespace cl { * handling of the exception has concluded. If set, it * will be returned by what(). */ - Error(cl_int err, const char * errStr = NULL) : err_(err), errStr_(errStr) + Error(cl_int err, const char * errStr = nullptr) : err_(err), errStr_(errStr) {} - ~Error() throw() {} - /*! \brief Get error string associated with exception * * \return A memory pointer to the error message string. */ - virtual const char * what() const throw () + const char * what() const noexcept override { - if (errStr_ == NULL) { + if (errStr_ == nullptr) { return "empty"; } else { @@ -792,7 +781,7 @@ namespace cl { }; #define CL_HPP_ERR_STR_(x) #x #else -#define CL_HPP_ERR_STR_(x) NULL +#define CL_HPP_ERR_STR_(x) nullptr #endif // CL_HPP_ENABLE_EXCEPTIONS @@ -801,7 +790,7 @@ namespace detail #if defined(CL_HPP_ENABLE_EXCEPTIONS) static inline cl_int errHandler ( cl_int err, - const char * errStr = NULL) + const char * errStr = nullptr) { if (err != CL_SUCCESS) { throw Error(err, errStr); @@ -809,7 +798,7 @@ static inline cl_int errHandler ( return err; } #else -static inline cl_int errHandler (cl_int err, const char * errStr = NULL) +static inline cl_int errHandler (cl_int err, const char * errStr = nullptr) { (void) errStr; // suppress unused variable warning return err; @@ -835,9 +824,11 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #if CL_HPP_TARGET_OPENCL_VERSION >= 120 #define __GET_KERNEL_ARG_INFO_ERR CL_HPP_ERR_STR_(clGetKernelArgInfo) #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 #define __GET_KERNEL_SUB_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelSubGroupInfo) -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 200 +#else +#define __GET_KERNEL_SUB_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelSubGroupInfoKHR) +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210 #define __GET_KERNEL_WORK_GROUP_INFO_ERR CL_HPP_ERR_STR_(clGetKernelWorkGroupInfo) #define __GET_PROGRAM_INFO_ERR CL_HPP_ERR_STR_(clGetProgramInfo) #define __GET_PROGRAM_BUILD_INFO_ERR CL_HPP_ERR_STR_(clGetProgramBuildInfo) @@ -846,6 +837,9 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #define __CREATE_CONTEXT_ERR CL_HPP_ERR_STR_(clCreateContext) #define __CREATE_CONTEXT_FROM_TYPE_ERR CL_HPP_ERR_STR_(clCreateContextFromType) #define __GET_SUPPORTED_IMAGE_FORMATS_ERR CL_HPP_ERR_STR_(clGetSupportedImageFormats) +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 +#define __SET_CONTEXT_DESCTRUCTOR_CALLBACK_ERR CL_HPP_ERR_STR_(clSetContextDestructorCallback) +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 #define __CREATE_BUFFER_ERR CL_HPP_ERR_STR_(clCreateBuffer) #define __COPY_ERR CL_HPP_ERR_STR_(cl::copy) @@ -868,12 +862,11 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #define __CREATE_KERNEL_ERR CL_HPP_ERR_STR_(clCreateKernel) #define __SET_KERNEL_ARGS_ERR CL_HPP_ERR_STR_(clSetKernelArg) #define __CREATE_PROGRAM_WITH_SOURCE_ERR CL_HPP_ERR_STR_(clCreateProgramWithSource) -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 -#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL) -#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 #define __CREATE_PROGRAM_WITH_BINARY_ERR CL_HPP_ERR_STR_(clCreateProgramWithBinary) #if CL_HPP_TARGET_OPENCL_VERSION >= 210 #define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithIL) +#else +#define __CREATE_PROGRAM_WITH_IL_ERR CL_HPP_ERR_STR_(clCreateProgramWithILKHR) #endif // CL_HPP_TARGET_OPENCL_VERSION >= 210 #if CL_HPP_TARGET_OPENCL_VERSION >= 120 #define __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR CL_HPP_ERR_STR_(clCreateProgramWithBuiltInKernels) @@ -904,6 +897,10 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #define __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueCopyImageToBuffer) #define __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueCopyBufferToImage) #define __ENQUEUE_MAP_BUFFER_ERR CL_HPP_ERR_STR_(clEnqueueMapBuffer) +#define __ENQUEUE_MAP_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMMap) +#define __ENQUEUE_FILL_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMMemFill) +#define __ENQUEUE_COPY_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMMemcpy) +#define __ENQUEUE_UNMAP_SVM_ERR CL_HPP_ERR_STR_(clEnqueueSVMUnmap) #define __ENQUEUE_MAP_IMAGE_ERR CL_HPP_ERR_STR_(clEnqueueMapImage) #define __ENQUEUE_UNMAP_MEM_OBJECT_ERR CL_HPP_ERR_STR_(clEnqueueUnMapMemObject) #define __ENQUEUE_NDRANGE_KERNEL_ERR CL_HPP_ERR_STR_(clEnqueueNDRangeKernel) @@ -923,7 +920,6 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #define __CREATE_PIPE_ERR CL_HPP_ERR_STR_(clCreatePipe) #define __GET_PIPE_INFO_ERR CL_HPP_ERR_STR_(clGetPipeInfo) - #define __RETAIN_ERR CL_HPP_ERR_STR_(Retain Object) #define __RELEASE_ERR CL_HPP_ERR_STR_(Release Object) #define __FLUSH_ERR CL_HPP_ERR_STR_(clFlush) @@ -939,6 +935,47 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #define __SET_PROGRAM_SPECIALIZATION_CONSTANT_ERR CL_HPP_ERR_STR_(clSetProgramSpecializationConstant) #endif +#ifdef cl_khr_external_memory +#define __ENQUEUE_ACQUIRE_EXTERNAL_MEMORY_ERR CL_HPP_ERR_STR_(clEnqueueAcquireExternalMemObjectsKHR) +#define __ENQUEUE_RELEASE_EXTERNAL_MEMORY_ERR CL_HPP_ERR_STR_(clEnqueueReleaseExternalMemObjectsKHR) +#endif + +#ifdef cl_khr_semaphore +#define __GET_SEMAPHORE_KHR_INFO_ERR CL_HPP_ERR_STR_(clGetSemaphoreInfoKHR) +#define __CREATE_SEMAPHORE_KHR_WITH_PROPERTIES_ERR CL_HPP_ERR_STR_(clCreateSemaphoreWithPropertiesKHR) +#define __ENQUEUE_WAIT_SEMAPHORE_KHR_ERR CL_HPP_ERR_STR_(clEnqueueWaitSemaphoresKHR) +#define __ENQUEUE_SIGNAL_SEMAPHORE_KHR_ERR CL_HPP_ERR_STR_(clEnqueueSignalSemaphoresKHR) +#define __RETAIN_SEMAPHORE_KHR_ERR CL_HPP_ERR_STR_(clRetainSemaphoreKHR) +#define __RELEASE_SEMAPHORE_KHR_ERR CL_HPP_ERR_STR_(clReleaseSemaphoreKHR) +#endif + +#ifdef cl_khr_external_semaphore +#define __GET_SEMAPHORE_HANDLE_FOR_TYPE_KHR_ERR CL_HPP_ERR_STR_(clGetSemaphoreHandleForTypeKHR) +#endif // cl_khr_external_semaphore + +#if defined(cl_khr_command_buffer) +#define __CREATE_COMMAND_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clCreateCommandBufferKHR) +#define __GET_COMMAND_BUFFER_INFO_KHR_ERR CL_HPP_ERR_STR_(clGetCommandBufferInfoKHR) +#define __FINALIZE_COMMAND_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clFinalizeCommandBufferKHR) +#define __ENQUEUE_COMMAND_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clEnqueueCommandBufferKHR) +#define __COMMAND_BARRIER_WITH_WAIT_LIST_KHR_ERR CL_HPP_ERR_STR_(clCommandBarrierWithWaitListKHR) +#define __COMMAND_COPY_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clCommandCopyBufferKHR) +#define __COMMAND_COPY_BUFFER_RECT_KHR_ERR CL_HPP_ERR_STR_(clCommandCopyBufferRectKHR) +#define __COMMAND_COPY_BUFFER_TO_IMAGE_KHR_ERR CL_HPP_ERR_STR_(clCommandCopyBufferToImageKHR) +#define __COMMAND_COPY_IMAGE_KHR_ERR CL_HPP_ERR_STR_(clCommandCopyImageKHR) +#define __COMMAND_COPY_IMAGE_TO_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clCommandCopyImageToBufferKHR) +#define __COMMAND_FILL_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clCommandFillBufferKHR) +#define __COMMAND_FILL_IMAGE_KHR_ERR CL_HPP_ERR_STR_(clCommandFillImageKHR) +#define __COMMAND_NDRANGE_KERNEL_KHR_ERR CL_HPP_ERR_STR_(clCommandNDRangeKernelKHR) +#define __UPDATE_MUTABLE_COMMANDS_KHR_ERR CL_HPP_ERR_STR_(clUpdateMutableCommandsKHR) +#define __GET_MUTABLE_COMMAND_INFO_KHR_ERR CL_HPP_ERR_STR_(clGetMutableCommandInfoKHR) +#define __RETAIN_COMMAND_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clRetainCommandBufferKHR) +#define __RELEASE_COMMAND_BUFFER_KHR_ERR CL_HPP_ERR_STR_(clReleaseCommandBufferKHR) +#endif // cl_khr_command_buffer + +#if defined(cl_ext_image_requirements_info) +#define __GET_IMAGE_REQUIREMENT_INFO_EXT_ERR CL_HPP_ERR_STR_(clGetImageRequirementsInfoEXT) +#endif //cl_ext_image_requirements_info /** * CL 1.2 version that uses device fission. @@ -987,6 +1024,87 @@ static inline cl_int errHandler (cl_int err, const char * errStr = NULL) #endif // CL_HPP_USER_OVERRIDE_ERROR_STRINGS //! \endcond +#ifdef cl_khr_external_memory +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clEnqueueAcquireExternalMemObjectsKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clEnqueueReleaseExternalMemObjectsKHR); + +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clEnqueueAcquireExternalMemObjectsKHR pfn_clEnqueueAcquireExternalMemObjectsKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clEnqueueReleaseExternalMemObjectsKHR pfn_clEnqueueReleaseExternalMemObjectsKHR = nullptr; +#endif // cl_khr_external_memory + +#ifdef cl_khr_semaphore +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCreateSemaphoreWithPropertiesKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clReleaseSemaphoreKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clRetainSemaphoreKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clEnqueueWaitSemaphoresKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clEnqueueSignalSemaphoresKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clGetSemaphoreInfoKHR); + +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCreateSemaphoreWithPropertiesKHR pfn_clCreateSemaphoreWithPropertiesKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clReleaseSemaphoreKHR pfn_clReleaseSemaphoreKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clRetainSemaphoreKHR pfn_clRetainSemaphoreKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clEnqueueWaitSemaphoresKHR pfn_clEnqueueWaitSemaphoresKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clEnqueueSignalSemaphoresKHR pfn_clEnqueueSignalSemaphoresKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clGetSemaphoreInfoKHR pfn_clGetSemaphoreInfoKHR = nullptr; +#endif // cl_khr_semaphore + +#ifdef cl_khr_external_semaphore +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clGetSemaphoreHandleForTypeKHR); +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clGetSemaphoreHandleForTypeKHR pfn_clGetSemaphoreHandleForTypeKHR = nullptr; +#endif // cl_khr_external_semaphore + +#if defined(cl_khr_command_buffer) +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCreateCommandBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clFinalizeCommandBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clRetainCommandBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clReleaseCommandBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clGetCommandBufferInfoKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clEnqueueCommandBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandBarrierWithWaitListKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandCopyBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandCopyBufferRectKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandCopyBufferToImageKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandCopyImageKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandCopyImageToBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandFillBufferKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandFillImageKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCommandNDRangeKernelKHR); + +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCreateCommandBufferKHR pfn_clCreateCommandBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clFinalizeCommandBufferKHR pfn_clFinalizeCommandBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clRetainCommandBufferKHR pfn_clRetainCommandBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clReleaseCommandBufferKHR pfn_clReleaseCommandBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clGetCommandBufferInfoKHR pfn_clGetCommandBufferInfoKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clEnqueueCommandBufferKHR pfn_clEnqueueCommandBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandBarrierWithWaitListKHR pfn_clCommandBarrierWithWaitListKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandCopyBufferKHR pfn_clCommandCopyBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandCopyBufferRectKHR pfn_clCommandCopyBufferRectKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandCopyBufferToImageKHR pfn_clCommandCopyBufferToImageKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandCopyImageKHR pfn_clCommandCopyImageKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandCopyImageToBufferKHR pfn_clCommandCopyImageToBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandFillBufferKHR pfn_clCommandFillBufferKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandFillImageKHR pfn_clCommandFillImageKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCommandNDRangeKernelKHR pfn_clCommandNDRangeKernelKHR = nullptr; +#endif /* cl_khr_command_buffer */ + +#if defined(cl_khr_command_buffer_mutable_dispatch) +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clUpdateMutableCommandsKHR); +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clGetMutableCommandInfoKHR); + +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clUpdateMutableCommandsKHR pfn_clUpdateMutableCommandsKHR = nullptr; +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clGetMutableCommandInfoKHR pfn_clGetMutableCommandInfoKHR = nullptr; +#endif /* cl_khr_command_buffer_mutable_dispatch */ + +#if defined(cl_ext_image_requirements_info) +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clGetImageRequirementsInfoEXT); +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clGetImageRequirementsInfoEXT pfn_clGetImageRequirementsInfoEXT = nullptr; +#endif + +#if defined(cl_ext_device_fission) +CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_(clCreateSubDevicesEXT); +CL_HPP_DEFINE_STATIC_MEMBER_ PFN_clCreateSubDevicesEXT + pfn_clCreateSubDevicesEXT = nullptr; +#endif namespace detail { @@ -997,7 +1115,7 @@ namespace detail { template inline cl_int getInfoHelper(Functor f, cl_uint name, T* param, long) { - return f(name, sizeof(T), param, NULL); + return f(name, sizeof(T), param, nullptr); } // Specialized for getInfo @@ -1018,14 +1136,13 @@ inline cl_int getInfoHelper(Func f, cl_uint name, vector>* binariesPointers[i] = (*param)[i].data(); } - cl_int err = f(name, numBinaries * sizeof(unsigned char*), binariesPointers.data(), NULL); + cl_int err = f(name, numBinaries * sizeof(unsigned char*), binariesPointers.data(), nullptr); if (err != CL_SUCCESS) { return err; } } - return CL_SUCCESS; } @@ -1034,7 +1151,7 @@ template inline cl_int getInfoHelper(Func f, cl_uint name, vector* param, long) { size_type required; - cl_int err = f(name, 0, NULL, &required); + cl_int err = f(name, 0, nullptr, &required); if (err != CL_SUCCESS) { return err; } @@ -1042,7 +1159,7 @@ inline cl_int getInfoHelper(Func f, cl_uint name, vector* param, long) // Temporary to avoid changing param on an error vector localData(elements); - err = f(name, required, localData.data(), NULL); + err = f(name, required, localData.data(), nullptr); if (err != CL_SUCCESS) { return err; } @@ -1064,7 +1181,7 @@ inline cl_int getInfoHelper( Func f, cl_uint name, vector* param, int, typename T::cl_type = 0) { size_type required; - cl_int err = f(name, 0, NULL, &required); + cl_int err = f(name, 0, nullptr, &required); if (err != CL_SUCCESS) { return err; } @@ -1072,7 +1189,7 @@ inline cl_int getInfoHelper( const size_type elements = required / sizeof(typename T::cl_type); vector value(elements); - err = f(name, required, value.data(), NULL); + err = f(name, required, value.data(), nullptr); if (err != CL_SUCCESS) { return err; } @@ -1095,7 +1212,7 @@ template inline cl_int getInfoHelper(Func f, cl_uint name, string* param, long) { size_type required; - cl_int err = f(name, 0, NULL, &required); + cl_int err = f(name, 0, nullptr, &required); if (err != CL_SUCCESS) { return err; } @@ -1104,12 +1221,12 @@ inline cl_int getInfoHelper(Func f, cl_uint name, string* param, long) // a char vector does not if (required > 0) { vector value(required); - err = f(name, required, value.data(), NULL); + err = f(name, required, value.data(), nullptr); if (err != CL_SUCCESS) { return err; } if (param) { - param->assign(begin(value), prev(end(value))); + param->assign(value.begin(), value.end() - 1); } } else if (param) { @@ -1123,7 +1240,7 @@ template inline cl_int getInfoHelper(Func f, cl_uint name, array* param, long) { size_type required; - cl_int err = f(name, 0, NULL, &required); + cl_int err = f(name, 0, nullptr, &required); if (err != CL_SUCCESS) { return err; } @@ -1131,7 +1248,7 @@ inline cl_int getInfoHelper(Func f, cl_uint name, array* param, lo size_type elements = required / sizeof(size_type); vector value(elements, 0); - err = f(name, required, value.data(), NULL); + err = f(name, required, value.data(), nullptr); if (err != CL_SUCCESS) { return err; } @@ -1160,12 +1277,12 @@ template inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_type = 0) { typename T::cl_type value; - cl_int err = f(name, sizeof(value), &value, NULL); + cl_int err = f(name, sizeof(value), &value, nullptr); if (err != CL_SUCCESS) { return err; } *param = value; - if (value != NULL) + if (value != nullptr) { err = param->retain(); if (err != CL_SUCCESS) { @@ -1226,7 +1343,7 @@ inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_ F(cl_device_info, CL_DEVICE_AVAILABLE, cl_bool) \ F(cl_device_info, CL_DEVICE_COMPILER_AVAILABLE, cl_bool) \ F(cl_device_info, CL_DEVICE_EXECUTION_CAPABILITIES, cl_device_exec_capabilities) \ - F(cl_device_info, CL_DEVICE_PLATFORM, cl_platform_id) \ + F(cl_device_info, CL_DEVICE_PLATFORM, cl::Platform) \ F(cl_device_info, CL_DEVICE_NAME, string) \ F(cl_device_info, CL_DEVICE_VENDOR, string) \ F(cl_device_info, CL_DRIVER_VERSION, string) \ @@ -1404,8 +1521,8 @@ inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_ F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_CTORS_PRESENT, cl_bool) \ F(cl_program_info, CL_PROGRAM_SCOPE_GLOBAL_DTORS_PRESENT, cl_bool) -#define CL_HPP_PARAM_NAME_DEVICE_FISSION_(F) \ - F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl_device_id) \ +#define CL_HPP_PARAM_NAME_DEVICE_FISSION_EXT_(F) \ + F(cl_device_info, CL_DEVICE_PARENT_DEVICE_EXT, cl::Device) \ F(cl_device_info, CL_DEVICE_PARTITION_TYPES_EXT, cl::vector) \ F(cl_device_info, CL_DEVICE_AFFINITY_DOMAINS_EXT, cl::vector) \ F(cl_device_info, CL_DEVICE_REFERENCE_COUNT_EXT , cl_uint) \ @@ -1423,6 +1540,37 @@ inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_ #define CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(F) \ F(cl_device_info, CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR, cl_version_khr) +// Note: the query for CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR is handled specially! +#define CL_HPP_PARAM_NAME_CL_KHR_SEMAPHORE_(F) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_CONTEXT_KHR, cl::Context) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_REFERENCE_COUNT_KHR, cl_uint) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_PROPERTIES_KHR, cl::vector) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_TYPE_KHR, cl_semaphore_type_khr) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_PAYLOAD_KHR, cl_semaphore_payload_khr) \ + F(cl_platform_info, CL_PLATFORM_SEMAPHORE_TYPES_KHR, cl::vector) \ + F(cl_device_info, CL_DEVICE_SEMAPHORE_TYPES_KHR, cl::vector) \ + +#define CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_MEMORY_(F) \ + F(cl_device_info, CL_DEVICE_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR, cl::vector) \ + F(cl_platform_info, CL_PLATFORM_EXTERNAL_MEMORY_IMPORT_HANDLE_TYPES_KHR, cl::vector) + +#define CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_(F) \ + F(cl_platform_info, CL_PLATFORM_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR, cl::vector) \ + F(cl_platform_info, CL_PLATFORM_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl::vector) \ + F(cl_device_info, CL_DEVICE_SEMAPHORE_IMPORT_HANDLE_TYPES_KHR, cl::vector) \ + F(cl_device_info, CL_DEVICE_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl::vector) \ + F(cl_semaphore_info_khr, CL_SEMAPHORE_EXPORT_HANDLE_TYPES_KHR, cl::vector) \ + +#define CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_OPAQUE_FD_EXT(F) \ + F(cl_external_semaphore_handle_type_khr, CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR, int) \ + +#define CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_SYNC_FD_EXT(F) \ + F(cl_external_semaphore_handle_type_khr, CL_SEMAPHORE_HANDLE_SYNC_FD_KHR, int) \ + +#define CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_WIN32_EXT(F) \ + F(cl_external_semaphore_handle_type_khr, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR, void*) \ + F(cl_external_semaphore_handle_type_khr, CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR, void*) \ + #define CL_HPP_PARAM_NAME_INFO_3_0_(F) \ F(cl_platform_info, CL_PLATFORM_NUMERIC_VERSION, cl_version) \ F(cl_platform_info, CL_PLATFORM_EXTENSIONS_WITH_VERSION, cl::vector) \ @@ -1446,7 +1594,32 @@ inline cl_int getInfoHelper(Func f, cl_uint name, T* param, int, typename T::cl_ F(cl_command_queue_info, CL_QUEUE_PROPERTIES_ARRAY, cl::vector) \ F(cl_mem_info, CL_MEM_PROPERTIES, cl::vector) \ F(cl_pipe_info, CL_PIPE_PROPERTIES, cl::vector) \ - F(cl_sampler_info, CL_SAMPLER_PROPERTIES, cl::vector) + F(cl_sampler_info, CL_SAMPLER_PROPERTIES, cl::vector) \ + +#define CL_HPP_PARAM_NAME_CL_IMAGE_REQUIREMENTS_EXT(F) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT, size_type) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT, size_type) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_SIZE_EXT, size_type) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT, cl_uint) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT, cl_uint) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT, cl_uint) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT, cl_uint) \ + +#define CL_HPP_PARAM_NAME_CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT(F) \ + F(cl_image_requirements_info_ext, CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT, size_type) \ + +#define CL_HPP_PARAM_NAME_CL_INTEL_COMMAND_QUEUE_FAMILIES_(F) \ + F(cl_device_info, CL_DEVICE_QUEUE_FAMILY_PROPERTIES_INTEL, cl::vector) \ + \ + F(cl_command_queue_info, CL_QUEUE_FAMILY_INTEL, cl_uint) \ + F(cl_command_queue_info, CL_QUEUE_INDEX_INTEL, cl_uint) + +#define CL_HPP_PARAM_NAME_CL_INTEL_UNIFIED_SHARED_MEMORY_(F) \ + F(cl_device_info, CL_DEVICE_HOST_MEM_CAPABILITIES_INTEL, cl_device_unified_shared_memory_capabilities_intel ) \ + F(cl_device_info, CL_DEVICE_DEVICE_MEM_CAPABILITIES_INTEL, cl_device_unified_shared_memory_capabilities_intel ) \ + F(cl_device_info, CL_DEVICE_SINGLE_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, cl_device_unified_shared_memory_capabilities_intel ) \ + F(cl_device_info, CL_DEVICE_CROSS_DEVICE_SHARED_MEM_CAPABILITIES_INTEL, cl_device_unified_shared_memory_capabilities_intel ) \ + F(cl_device_info, CL_DEVICE_SHARED_SYSTEM_MEM_CAPABILITIES_INTEL, cl_device_unified_shared_memory_capabilities_intel ) template struct param_traits {}; @@ -1480,13 +1653,13 @@ CL_HPP_PARAM_NAME_INFO_2_2_(CL_HPP_DECLARE_PARAM_TRAITS_) CL_HPP_PARAM_NAME_INFO_3_0_(CL_HPP_DECLARE_PARAM_TRAITS_) #endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 -#if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210 +#if defined(cl_khr_subgroups) && CL_HPP_TARGET_OPENCL_VERSION < 210 CL_HPP_PARAM_NAME_INFO_SUBGROUP_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_) -#endif // #if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210 +#endif // #if defined(cl_khr_subgroups) && CL_HPP_TARGET_OPENCL_VERSION < 210 -#if defined(CL_HPP_USE_IL_KHR) && CL_HPP_TARGET_OPENCL_VERSION < 210 +#if defined(cl_khr_il_program) && CL_HPP_TARGET_OPENCL_VERSION < 210 CL_HPP_PARAM_NAME_INFO_IL_KHR_(CL_HPP_DECLARE_PARAM_TRAITS_) -#endif // #if defined(CL_HPP_USE_IL_KHR) +#endif // #if defined(cl_khr_il_program) && CL_HPP_TARGET_OPENCL_VERSION < 210 // Flags deprecated in OpenCL 2.0 @@ -1511,9 +1684,9 @@ CL_HPP_PARAM_NAME_INFO_1_1_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_) CL_HPP_PARAM_NAME_INFO_1_2_DEPRECATED_IN_2_0_(CL_HPP_DECLARE_PARAM_TRAITS_) #endif // CL_HPP_MINIMUM_OPENCL_VERSION < 200 -#if defined(CL_HPP_USE_CL_DEVICE_FISSION) -CL_HPP_PARAM_NAME_DEVICE_FISSION_(CL_HPP_DECLARE_PARAM_TRAITS_); -#endif // CL_HPP_USE_CL_DEVICE_FISSION +#if defined(cl_ext_device_fission) +CL_HPP_PARAM_NAME_DEVICE_FISSION_EXT_(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_ext_device_fission #if defined(cl_khr_extended_versioning) #if CL_HPP_TARGET_OPENCL_VERSION < 300 @@ -1522,6 +1695,31 @@ CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_CL3_SHARED_(CL_HPP_DECLARE_PARAM_TR CL_HPP_PARAM_NAME_CL_KHR_EXTENDED_VERSIONING_KHRONLY_(CL_HPP_DECLARE_PARAM_TRAITS_) #endif // cl_khr_extended_versioning +#if defined(cl_khr_semaphore) +CL_HPP_PARAM_NAME_CL_KHR_SEMAPHORE_(CL_HPP_DECLARE_PARAM_TRAITS_) +#if defined(CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_semaphore_info_khr, CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR, cl::vector) +#endif // defined(CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR) +#endif // defined(cl_khr_semaphore) + +#ifdef cl_khr_external_memory +CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_MEMORY_(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_khr_external_memory + +#if defined(cl_khr_external_semaphore) +CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_khr_external_semaphore + +#if defined(cl_khr_external_semaphore_opaque_fd) +CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_OPAQUE_FD_EXT(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_khr_external_semaphore_opaque_fd +#if defined(cl_khr_external_semaphore_sync_fd) +CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_SYNC_FD_EXT(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_khr_external_semaphore_sync_fd +#if defined(cl_khr_external_semaphore_win32) +CL_HPP_PARAM_NAME_CL_KHR_EXTERNAL_SEMAPHORE_WIN32_EXT(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_khr_external_semaphore_win32 + #if defined(cl_khr_device_uuid) using uuid_array = array; using luid_array = array; @@ -1536,6 +1734,16 @@ CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NODE_MASK_KHR, cl_uint) CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_PCI_BUS_INFO_KHR, cl_device_pci_bus_info_khr) #endif +// Note: some headers do not define cl_khr_image2d_from_buffer +#if CL_HPP_TARGET_OPENCL_VERSION < 200 +#if defined(CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_IMAGE_PITCH_ALIGNMENT_KHR, cl_uint) +#endif +#if defined(CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT_KHR, cl_uint) +#endif +#endif // CL_HPP_TARGET_OPENCL_VERSION < 200 + #if defined(cl_khr_integer_dot_product) CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_CAPABILITIES_KHR, cl_device_integer_dot_product_capabilities_khr) #if defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR) @@ -1544,6 +1752,14 @@ CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGER_DOT_PRODUCT_ACCEL #endif // defined(CL_DEVICE_INTEGER_DOT_PRODUCT_ACCELERATION_PROPERTIES_8BIT_KHR) #endif // defined(cl_khr_integer_dot_product) +#if defined(cl_ext_image_requirements_info) +CL_HPP_PARAM_NAME_CL_IMAGE_REQUIREMENTS_EXT(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_ext_image_requirements_info + +#if defined(cl_ext_image_from_buffer) +CL_HPP_PARAM_NAME_CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_ext_image_from_buffer + #ifdef CL_PLATFORM_ICD_SUFFIX_KHR CL_HPP_DECLARE_PARAM_TRAITS_(cl_platform_info, CL_PLATFORM_ICD_SUFFIX_KHR, string) #endif @@ -1597,12 +1813,24 @@ CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SCHEDULING_CONTROLS_CAPAB #ifdef CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SUPPORTED_REGISTER_ALLOCATIONS_ARM, vector) #endif +#ifdef CL_DEVICE_MAX_WARP_COUNT_ARM +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_MAX_WARP_COUNT_ARM, cl_uint) +#endif +#ifdef CL_KERNEL_MAX_WARP_COUNT_ARM +CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_info, CL_KERNEL_MAX_WARP_COUNT_ARM, cl_uint) +#endif #ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_ARM, cl_uint) #endif #ifdef CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WORKGROUP_BATCH_SIZE_MODIFIER_ARM, cl_int) #endif +#ifdef CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM +CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_WARP_COUNT_LIMIT_ARM, cl_uint) +#endif +#ifdef CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM +CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_exec_info, CL_KERNEL_EXEC_INFO_COMPUTE_UNIT_MAX_QUEUED_BATCHES_ARM, cl_uint) +#endif #ifdef CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMPUTE_CAPABILITY_MAJOR_NV, cl_uint) @@ -1626,6 +1854,66 @@ CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_KERNEL_EXEC_TIMEOUT_NV, c CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_INTEGRATED_MEMORY_NV, cl_bool) #endif +#if defined(cl_khr_command_buffer) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMMAND_BUFFER_CAPABILITIES_KHR, cl_device_command_buffer_capabilities_khr) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_COMMAND_BUFFER_REQUIRED_QUEUE_PROPERTIES_KHR, cl_command_queue_properties) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_command_buffer_info_khr, CL_COMMAND_BUFFER_QUEUES_KHR, cl::vector) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_command_buffer_info_khr, CL_COMMAND_BUFFER_NUM_QUEUES_KHR, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_command_buffer_info_khr, CL_COMMAND_BUFFER_REFERENCE_COUNT_KHR, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_command_buffer_info_khr, CL_COMMAND_BUFFER_STATE_KHR, cl_command_buffer_state_khr) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_command_buffer_info_khr, CL_COMMAND_BUFFER_PROPERTIES_ARRAY_KHR, cl::vector) +#endif /* cl_khr_command_buffer */ + +#if defined(cl_khr_command_buffer_mutable_dispatch) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_COMMAND_COMMAND_QUEUE_KHR, CommandQueue) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_COMMAND_COMMAND_BUFFER_KHR, CommandBufferKhr) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_COMMAND_COMMAND_TYPE_KHR, cl_command_type) + +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 2) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_COMMAND_PROPERTIES_ARRAY_KHR, cl::vector) +#else +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_PROPERTIES_ARRAY_KHR, cl::vector) +#endif +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_KERNEL_KHR, cl_kernel) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_DIMENSIONS_KHR, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_GLOBAL_WORK_OFFSET_KHR, cl::vector) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_GLOBAL_WORK_SIZE_KHR, cl::vector) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_mutable_command_info_khr, CL_MUTABLE_DISPATCH_LOCAL_WORK_SIZE_KHR, cl::vector) +#endif /* cl_khr_command_buffer_mutable_dispatch */ + +#if defined(cl_khr_kernel_clock) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_KERNEL_CLOCK_CAPABILITIES_KHR, cl_device_kernel_clock_capabilities_khr) +#endif /* cl_khr_kernel_clock */ + +#if defined(cl_ext_float_atomics) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SINGLE_FP_ATOMIC_CAPABILITIES_EXT, cl_device_fp_atomic_capabilities_ext) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_DOUBLE_FP_ATOMIC_CAPABILITIES_EXT, cl_device_fp_atomic_capabilities_ext) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_HALF_FP_ATOMIC_CAPABILITIES_EXT, cl_device_fp_atomic_capabilities_ext) +#endif /* cl_ext_float_atomics */ + +#if defined(cl_intel_command_queue_families) +CL_HPP_PARAM_NAME_CL_INTEL_COMMAND_QUEUE_FAMILIES_(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_intel_command_queue_families + +#if defined(cl_intel_device_attribute_query) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_IP_VERSION_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_ID_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NUM_SLICES_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NUM_SUB_SLICES_PER_SLICE_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NUM_EUS_PER_SUB_SLICE_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_NUM_THREADS_PER_EU_INTEL, cl_uint) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_FEATURE_CAPABILITIES_INTEL, cl_device_feature_capabilities_intel) +#endif // cl_intel_device_attribute_query + +#if defined(cl_intel_required_subgroup_size) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_device_info, CL_DEVICE_SUB_GROUP_SIZES_INTEL, cl::vector) +CL_HPP_DECLARE_PARAM_TRAITS_(cl_kernel_work_group_info, CL_KERNEL_SPILL_MEM_SIZE_INTEL, cl_ulong) +#endif // cl_intel_required_subgroup_size + +#if defined(cl_intel_unified_shared_memory) +CL_HPP_PARAM_NAME_CL_INTEL_UNIFIED_SHARED_MEMORY_(CL_HPP_DECLARE_PARAM_TRAITS_) +#endif // cl_intel_unified_shared_memory + // Convenience functions template @@ -1794,8 +2082,65 @@ struct ReferenceHandler { return ::clReleaseEvent(event); } }; +#ifdef cl_khr_semaphore +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_semaphore_khr semaphore) + { + if (pfn_clRetainSemaphoreKHR != nullptr) { + return pfn_clRetainSemaphoreKHR(semaphore); + } + + return CL_INVALID_OPERATION; + } + + static cl_int release(cl_semaphore_khr semaphore) + { + if (pfn_clReleaseSemaphoreKHR != nullptr) { + return pfn_clReleaseSemaphoreKHR(semaphore); + } -#if CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120 + return CL_INVALID_OPERATION; + } +}; +#endif // cl_khr_semaphore +#if defined(cl_khr_command_buffer) +template <> +struct ReferenceHandler +{ + static cl_int retain(cl_command_buffer_khr cmdBufferKhr) + { + if (pfn_clRetainCommandBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, __RETAIN_COMMAND_BUFFER_KHR_ERR); + } + return pfn_clRetainCommandBufferKHR(cmdBufferKhr); + } + + static cl_int release(cl_command_buffer_khr cmdBufferKhr) + { + if (pfn_clReleaseCommandBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, __RELEASE_COMMAND_BUFFER_KHR_ERR); + } + return pfn_clReleaseCommandBufferKHR(cmdBufferKhr); + } +}; + +template <> +struct ReferenceHandler +{ + // cl_mutable_command_khr does not have retain(). + static cl_int retain(cl_mutable_command_khr) + { return CL_SUCCESS; } + // cl_mutable_command_khr does not have release(). + static cl_int release(cl_mutable_command_khr) + { return CL_SUCCESS; } +}; +#endif // cl_khr_command_buffer + + +#if (CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120) || \ + (CL_HPP_TARGET_OPENCL_VERSION >= 200 && CL_HPP_MINIMUM_OPENCL_VERSION < 200) // Extracts version number with major in the upper 16 bits, minor in the lower 16 static cl_uint getVersion(const vector &versionInfo) { @@ -1819,7 +2164,7 @@ static cl_uint getVersion(const vector &versionInfo) static cl_uint getPlatformVersion(cl_platform_id platform) { size_type size = 0; - clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, NULL, &size); + clGetPlatformInfo(platform, CL_PLATFORM_VERSION, 0, nullptr, &size); vector versionInfo(size); clGetPlatformInfo(platform, CL_PLATFORM_VERSION, size, versionInfo.data(), &size); @@ -1829,7 +2174,7 @@ static cl_uint getPlatformVersion(cl_platform_id platform) static cl_uint getDevicePlatformVersion(cl_device_id device) { cl_platform_id platform; - clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, NULL); + clGetDeviceInfo(device, CL_DEVICE_PLATFORM, sizeof(platform), &platform, nullptr); return getPlatformVersion(platform); } @@ -1838,14 +2183,14 @@ static cl_uint getContextPlatformVersion(cl_context context) // The platform cannot be queried directly, so we first have to grab a // device and obtain its context size_type size = 0; - clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, NULL, &size); + clGetContextInfo(context, CL_CONTEXT_DEVICES, 0, nullptr, &size); if (size == 0) return 0; vector devices(size/sizeof(cl_device_id)); - clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices.data(), NULL); + clGetContextInfo(context, CL_CONTEXT_DEVICES, size, devices.data(), nullptr); return getDevicePlatformVersion(devices[0]); } -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120 +#endif // CL_HPP_TARGET_OPENCL_VERSION && CL_HPP_MINIMUM_OPENCL_VERSION template class Wrapper @@ -1857,7 +2202,7 @@ class Wrapper cl_type object_; public: - Wrapper() : object_(NULL) { } + Wrapper() : object_(nullptr) { } Wrapper(const cl_type &obj, bool retainObject) : object_(obj) { @@ -1868,7 +2213,7 @@ class Wrapper ~Wrapper() { - if (object_ != NULL) { release(); } + if (object_ != nullptr) { release(); } } Wrapper(const Wrapper& rhs) @@ -1877,10 +2222,10 @@ class Wrapper detail::errHandler(retain(), __RETAIN_ERR); } - Wrapper(Wrapper&& rhs) CL_HPP_NOEXCEPT_ + Wrapper(Wrapper&& rhs) noexcept { object_ = rhs.object_; - rhs.object_ = NULL; + rhs.object_ = nullptr; } Wrapper& operator = (const Wrapper& rhs) @@ -1898,7 +2243,7 @@ class Wrapper if (this != &rhs) { detail::errHandler(release(), __RELEASE_ERR); object_ = rhs.object_; - rhs.object_ = NULL; + rhs.object_ = nullptr; } return *this; } @@ -1954,24 +2299,22 @@ class Wrapper static bool isReferenceCountable(cl_device_id device) { bool retVal = false; -#if CL_HPP_TARGET_OPENCL_VERSION >= 120 -#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 - if (device != NULL) { +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 && CL_HPP_MINIMUM_OPENCL_VERSION < 120 + if (device != nullptr) { int version = getDevicePlatformVersion(device); if(version > ((1 << 16) + 1)) { retVal = true; } } -#else // CL_HPP_MINIMUM_OPENCL_VERSION < 120 +#elif CL_HPP_TARGET_OPENCL_VERSION >= 120 retVal = true; -#endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120 -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 +#endif // CL_HPP_TARGET_OPENCL_VERSION (void)device; return retVal; } public: - Wrapper() : object_(NULL), referenceCountable_(false) + Wrapper() : object_(nullptr), referenceCountable_(false) { } @@ -1998,11 +2341,11 @@ class Wrapper detail::errHandler(retain(), __RETAIN_ERR); } - Wrapper(Wrapper&& rhs) CL_HPP_NOEXCEPT_ + Wrapper(Wrapper&& rhs) noexcept { object_ = rhs.object_; referenceCountable_ = rhs.referenceCountable_; - rhs.object_ = NULL; + rhs.object_ = nullptr; rhs.referenceCountable_ = false; } @@ -2023,7 +2366,7 @@ class Wrapper detail::errHandler(release(), __RELEASE_ERR); object_ = rhs.object_; referenceCountable_ = rhs.referenceCountable_; - rhs.object_ = NULL; + rhs.object_ = nullptr; rhs.referenceCountable_ = false; } return *this; @@ -2164,7 +2507,7 @@ class Device : public detail::Wrapper } #endif // #ifdef CL_HPP_UNIT_TEST_ENABLE - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Device() : detail::Wrapper() { } /*! \brief Constructor from cl_device_id. @@ -2179,11 +2522,11 @@ class Device : public detail::Wrapper * \see Context::getDefault() */ static Device getDefault( - cl_int *errResult = NULL) + cl_int *errResult = nullptr) { std::call_once(default_initialized_, makeDefault); detail::errHandler(default_error_); - if (errResult != NULL) { + if (errResult != nullptr) { *errResult = default_error_; } return default_; @@ -2212,34 +2555,7 @@ class Device : public detail::Wrapper detail::Wrapper::operator=(rhs); return *this; } - - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Device(const Device& dev) : detail::Wrapper(dev) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Device& operator = (const Device &dev) - { - detail::Wrapper::operator=(dev); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Device(Device&& dev) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(dev)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Device& operator = (Device &&dev) - { - detail::Wrapper::operator=(std::move(dev)); - return *this; - } + //! \brief Wrapper for clGetDeviceInfo(). template @@ -2253,18 +2569,17 @@ class Device : public detail::Wrapper //! \brief Wrapper for clGetDeviceInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_device_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; } - #if CL_HPP_TARGET_OPENCL_VERSION >= 210 /** * Return the current value of the host clock as seen by the device. @@ -2311,90 +2626,17 @@ class Device : public detail::Wrapper } #endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 210 - /** - * CL 1.2 version - */ #if CL_HPP_TARGET_OPENCL_VERSION >= 120 //! \brief Wrapper for clCreateSubDevices(). - cl_int createSubDevices( - const cl_device_partition_property * properties, - vector* devices) - { - cl_uint n = 0; - cl_int err = clCreateSubDevices(object_, properties, 0, NULL, &n); - if (err != CL_SUCCESS) { - return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); - } - - vector ids(n); - err = clCreateSubDevices(object_, properties, n, ids.data(), NULL); - if (err != CL_SUCCESS) { - return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); - } - - // Cannot trivially assign because we need to capture intermediates - // with safe construction - if (devices) { - devices->resize(ids.size()); - - // Assign to param, constructing with retain behaviour - // to correctly capture each underlying CL object - for (size_type i = 0; i < ids.size(); i++) { - // We do not need to retain because this device is being created - // by the runtime - (*devices)[i] = Device(ids[i], false); - } - } - - return CL_SUCCESS; - } -#elif defined(CL_HPP_USE_CL_DEVICE_FISSION) - -/** - * CL 1.1 version that uses device fission extension. - */ - cl_int createSubDevices( - const cl_device_partition_property_ext * properties, - vector* devices) - { - typedef CL_API_ENTRY cl_int - ( CL_API_CALL * PFN_clCreateSubDevicesEXT)( - cl_device_id /*in_device*/, - const cl_device_partition_property_ext * /* properties */, - cl_uint /*num_entries*/, - cl_device_id * /*out_devices*/, - cl_uint * /*num_devices*/ ) CL_API_SUFFIX__VERSION_1_1; - - static PFN_clCreateSubDevicesEXT pfn_clCreateSubDevicesEXT = NULL; - CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateSubDevicesEXT); - - cl_uint n = 0; - cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, NULL, &n); - if (err != CL_SUCCESS) { - return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); - } - - vector ids(n); - err = pfn_clCreateSubDevicesEXT(object_, properties, n, ids.data(), NULL); - if (err != CL_SUCCESS) { - return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); - } - // Cannot trivially assign because we need to capture intermediates - // with safe construction - if (devices) { - devices->resize(ids.size()); + cl_int createSubDevices(const cl_device_partition_property* properties, + vector* devices); +#endif // defined (CL_HPP_TARGET_OPENCL_VERSION >= 120) - // Assign to param, constructing with retain behaviour - // to correctly capture each underlying CL object - for (size_type i = 0; i < ids.size(); i++) { - // We do not need to retain because this device is being created - // by the runtime - (*devices)[i] = Device(ids[i], false); - } - } - return CL_SUCCESS; - } -#endif // defined(CL_HPP_USE_CL_DEVICE_FISSION) +#if defined(cl_ext_device_fission) + //! \brief Wrapper for clCreateSubDevices(). + cl_int createSubDevices(const cl_device_partition_property_ext* properties, + vector* devices); +#endif // defined(cl_ext_device_fission) }; using BuildLogType = vector::param_type>>; @@ -2478,7 +2720,7 @@ class Platform : public detail::Wrapper // Otherwise set it cl_uint n = 0; - cl_int err = ::clGetPlatformIDs(0, NULL, &n); + cl_int err = ::clGetPlatformIDs(0, nullptr, &n); if (err != CL_SUCCESS) { default_error_ = err; return; @@ -2489,7 +2731,7 @@ class Platform : public detail::Wrapper } vector ids(n); - err = ::clGetPlatformIDs(n, ids.data(), NULL); + err = ::clGetPlatformIDs(n, ids.data(), nullptr); if (err != CL_SUCCESS) { default_error_ = err; return; @@ -2526,7 +2768,7 @@ class Platform : public detail::Wrapper } #endif // #ifdef CL_HPP_UNIT_TEST_ENABLE - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Platform() : detail::Wrapper() { } /*! \brief Constructor from cl_platform_id. @@ -2550,11 +2792,11 @@ class Platform : public detail::Wrapper } static Platform getDefault( - cl_int *errResult = NULL) + cl_int *errResult = nullptr) { std::call_once(default_initialized_, makeDefault); detail::errHandler(default_error_); - if (errResult != NULL) { + if (errResult != nullptr) { *errResult = default_error_; } return default_; @@ -2586,12 +2828,12 @@ class Platform : public detail::Wrapper //! \brief Wrapper for clGetPlatformInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_platform_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -2606,17 +2848,17 @@ class Platform : public detail::Wrapper vector* devices) const { cl_uint n = 0; - if( devices == NULL ) { + if( devices == nullptr ) { return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR); } - cl_int err = ::clGetDeviceIDs(object_, type, 0, NULL, &n); + cl_int err = ::clGetDeviceIDs(object_, type, 0, nullptr, &n); if (err != CL_SUCCESS && err != CL_DEVICE_NOT_FOUND) { return detail::errHandler(err, __GET_DEVICE_IDS_ERR); } vector ids(n); if (n>0) { - err = ::clGetDeviceIDs(object_, type, n, ids.data(), NULL); + err = ::clGetDeviceIDs(object_, type, n, ids.data(), nullptr); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_DEVICE_IDS_ERR); } @@ -2649,7 +2891,7 @@ class Platform : public detail::Wrapper * * \param devices returns a vector of OpenCL D3D10 devices found. The cl::Device * values returned in devices can be used to identify a specific OpenCL - * device. If \a devices argument is NULL, this argument is ignored. + * device. If \a devices argument is nullptr, this argument is ignored. * * \return One of the following values: * - CL_SUCCESS if the function is executed successfully. @@ -2677,12 +2919,17 @@ class Platform : public detail::Wrapper cl_device_id * devices, cl_uint* num_devices); - if( devices == NULL ) { + if( devices == nullptr ) { return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_DEVICE_IDS_ERR); } - static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = NULL; + static PFN_clGetDeviceIDsFromD3D10KHR pfn_clGetDeviceIDsFromD3D10KHR = nullptr; +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(object_, clGetDeviceIDsFromD3D10KHR); +#endif +#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetDeviceIDsFromD3D10KHR); +#endif cl_uint n = 0; cl_int err = pfn_clGetDeviceIDsFromD3D10KHR( @@ -2691,7 +2938,7 @@ class Platform : public detail::Wrapper d3d_object, d3d_device_set, 0, - NULL, + nullptr, &n); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_DEVICE_IDS_ERR); @@ -2705,7 +2952,7 @@ class Platform : public detail::Wrapper d3d_device_set, n, ids.data(), - NULL); + nullptr); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_DEVICE_IDS_ERR); } @@ -2736,17 +2983,17 @@ class Platform : public detail::Wrapper { cl_uint n = 0; - if( platforms == NULL ) { + if( platforms == nullptr ) { return detail::errHandler(CL_INVALID_ARG_VALUE, __GET_PLATFORM_IDS_ERR); } - cl_int err = ::clGetPlatformIDs(0, NULL, &n); + cl_int err = ::clGetPlatformIDs(0, nullptr, &n); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); } vector ids(n); - err = ::clGetPlatformIDs(n, ids.data(), NULL); + err = ::clGetPlatformIDs(n, ids.data(), nullptr); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_PLATFORM_IDS_ERR); } @@ -2786,7 +3033,7 @@ class Platform : public detail::Wrapper * Wraps clGetPlatformIDs(), returning the first result. */ static Platform get( - cl_int * errResult = NULL) + cl_int * errResult = nullptr) { cl_int err; Platform default_platform = Platform::getDefault(&err); @@ -2806,6 +3053,93 @@ class Platform : public detail::Wrapper #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 }; // class Platform +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + //! \brief Wrapper for clCreateSubDevices(). +inline cl_int Device::createSubDevices(const cl_device_partition_property* properties, + vector* devices) +{ + cl_uint n = 0; + cl_int err = clCreateSubDevices(object_, properties, 0, nullptr, &n); + if (err != CL_SUCCESS) + { + return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); + } + + vector ids(n); + err = clCreateSubDevices(object_, properties, n, ids.data(), nullptr); + if (err != CL_SUCCESS) + { + return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); + } + + // Cannot trivially assign because we need to capture intermediates + // with safe construction + if (devices) + { + devices->resize(ids.size()); + + // Assign to param, constructing with retain behaviour + // to correctly capture each underlying CL object + for (size_type i = 0; i < ids.size(); i++) + { + // We do not need to retain because this device is being created + // by the runtime + (*devices)[i] = Device(ids[i], false); + } + } + + return CL_SUCCESS; +} +#endif // defined (CL_HPP_TARGET_OPENCL_VERSION >= 120) + +#if defined(cl_ext_device_fission) + //! \brief Wrapper for clCreateSubDevices(). +inline cl_int Device::createSubDevices(const cl_device_partition_property_ext* properties, + vector* devices) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl::Device device(object_); + cl_platform_id platform = device.getInfo()(); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCreateSubDevicesEXT); +#endif +#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateSubDevicesEXT); +#endif + + cl_uint n = 0; + cl_int err = pfn_clCreateSubDevicesEXT(object_, properties, 0, nullptr, &n); + if (err != CL_SUCCESS) + { + return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); + } + + vector ids(n); + err = + pfn_clCreateSubDevicesEXT(object_, properties, n, ids.data(), nullptr); + if (err != CL_SUCCESS) + { + return detail::errHandler(err, __CREATE_SUB_DEVICES_ERR); + } + // Cannot trivially assign because we need to capture intermediates + // with safe construction + if (devices) + { + devices->resize(ids.size()); + + // Assign to param, constructing with retain behaviour + // to correctly capture each underlying CL object + for (size_type i = 0; i < ids.size(); i++) + { + // We do not need to retain because this device is being created + // by the runtime + (*devices)[i] = Device(ids[i], false); + } + } + + return CL_SUCCESS; +} +#endif // defined(cl_ext_device_fission) + CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Platform::default_initialized_; CL_HPP_DEFINE_STATIC_MEMBER_ Platform Platform::default_; CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Platform::default_error_ = CL_SUCCESS; @@ -2828,6 +3162,25 @@ UnloadCompiler() } #endif // #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) + +#if defined(cl_ext_image_requirements_info) +enum ImageRequirementsInfoExt : cl_image_requirements_info_ext +{ + RowPitchAlign = CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT, + BaseAddAlign = CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT, + Size = CL_IMAGE_REQUIREMENTS_SIZE_EXT, + MaxWidth = CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT, + MaxHeight = CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT, + MaxDepth = CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT, + MaxArraySize = CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT, +#if defined(cl_ext_image_from_buffer) + SlicePitchAlign = CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT, +#endif +}; + +#endif // cl_ext_image_requirements_info + + /*! \brief Class interface for cl_context. * * \note Copies of these objects are shallow, meaning that the copy will refer @@ -2870,8 +3223,8 @@ class Context default_ = Context( CL_DEVICE_TYPE_DEFAULT, properties, - NULL, - NULL, + nullptr, + nullptr, &default_error_); } #if defined(CL_HPP_ENABLE_EXCEPTIONS) @@ -2890,6 +3243,51 @@ class Context static void makeDefaultProvided(const Context &c) { default_ = c; } + +#if defined(cl_ext_image_requirements_info) + struct ImageRequirementsInfo { + + ImageRequirementsInfo(cl_mem_flags f, const cl_mem_properties* mem_properties, const ImageFormat* format, const cl_image_desc* desc) + { + flags = f; + properties = mem_properties; + image_format = format; + image_desc = desc; + } + + cl_mem_flags flags = 0; + const cl_mem_properties* properties; + const ImageFormat* image_format; + const cl_image_desc* image_desc; + }; + + static cl_int getImageRequirementsInfoExtHelper(const Context &context, + const ImageRequirementsInfo &info, + cl_image_requirements_info_ext param_name, + size_type param_value_size, + void* param_value, + size_type* param_value_size_ret) + { + +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + Device device = context.getInfo().at(0); + cl_platform_id platform = device.getInfo()(); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clGetImageRequirementsInfoEXT); +#else + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetImageRequirementsInfoEXT); +#endif + + if (pfn_clGetImageRequirementsInfoEXT == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, __GET_IMAGE_REQUIREMENT_INFO_EXT_ERR); + } + + return detail::errHandler( + pfn_clGetImageRequirementsInfoEXT(context(), info.properties, + info.flags, info.image_format, info.image_desc, param_name, + param_value_size, param_value, param_value_size_ret), + __GET_IMAGE_REQUIREMENT_INFO_EXT_ERR); + } +#endif // cl_ext_image_requirements_info public: #ifdef CL_HPP_UNIT_TEST_ENABLE @@ -2910,14 +3308,14 @@ class Context */ Context( const vector& devices, - const cl_context_properties* properties = NULL, + const cl_context_properties* properties = nullptr, void (CL_CALLBACK * notifyFptr)( const char *, const void *, size_type, - void *) = NULL, - void* data = NULL, - cl_int* err = NULL) + void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) { cl_int error; @@ -2934,7 +3332,7 @@ class Context notifyFptr, data, &error); detail::errHandler(error, __CREATE_CONTEXT_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -2945,14 +3343,14 @@ class Context */ Context( const Device& device, - const cl_context_properties* properties = NULL, + const cl_context_properties* properties = nullptr, void (CL_CALLBACK * notifyFptr)( const char *, const void *, size_type, - void *) = NULL, - void* data = NULL, - cl_int* err = NULL) + void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) { cl_int error; @@ -2964,7 +3362,7 @@ class Context notifyFptr, data, &error); detail::errHandler(error, __CREATE_CONTEXT_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -2975,27 +3373,27 @@ class Context */ Context( cl_device_type type, - const cl_context_properties* properties = NULL, + const cl_context_properties* properties = nullptr, void (CL_CALLBACK * notifyFptr)( const char *, const void *, size_type, - void *) = NULL, - void* data = NULL, - cl_int* err = NULL) + void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) { cl_int error; #if !defined(__APPLE__) && !defined(__MACOS) cl_context_properties prop[4] = {CL_CONTEXT_PLATFORM, 0, 0, 0 }; - if (properties == NULL) { + if (properties == nullptr) { // Get a valid platform ID as we cannot send in a blank one vector platforms; error = Platform::get(&platforms); if (error != CL_SUCCESS) { detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } return; @@ -3024,7 +3422,7 @@ class Context // Only squash CL_SUCCESS and CL_DEVICE_NOT_FOUND if (error != CL_SUCCESS && error != CL_DEVICE_NOT_FOUND) { detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -3037,7 +3435,7 @@ class Context if (platform_id == 0) { detail::errHandler(CL_DEVICE_NOT_FOUND, __CREATE_CONTEXT_FROM_TYPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = CL_DEVICE_NOT_FOUND; } return; @@ -3051,49 +3449,21 @@ class Context properties, type, notifyFptr, data, &error); detail::errHandler(error, __CREATE_CONTEXT_FROM_TYPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Context(const Context& ctx) : detail::Wrapper(ctx) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Context& operator = (const Context &ctx) - { - detail::Wrapper::operator=(ctx); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Context(Context&& ctx) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(ctx)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Context& operator = (Context &&ctx) - { - detail::Wrapper::operator=(std::move(ctx)); - return *this; - } - /*! \brief Returns a singleton context including all devices of CL_DEVICE_TYPE_DEFAULT. * * \note All calls to this function return the same cl_context as the first. */ - static Context getDefault(cl_int * err = NULL) + static Context getDefault(cl_int * err = nullptr) { std::call_once(default_initialized_, makeDefault); detail::errHandler(default_error_); - if (err != NULL) { + if (err != nullptr) { *err = default_error_; } return default_; @@ -3113,7 +3483,7 @@ class Context return default_; } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Context() : detail::Wrapper() { } /*! \brief Constructor from cl_context - takes ownership. @@ -3147,12 +3517,12 @@ class Context //! \brief Wrapper for clGetContextInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_context_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -3178,7 +3548,7 @@ class Context flags, type, 0, - NULL, + nullptr, &numEntries); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR); @@ -3192,12 +3562,12 @@ class Context type, numEntries, (cl_image_format*)value.data(), - NULL); + nullptr); if (err != CL_SUCCESS) { return detail::errHandler(err, __GET_SUPPORTED_IMAGE_FORMATS_ERR); } - formats->assign(begin(value), end(value)); + formats->assign(value.begin(), value.end()); } else { // If no values are being returned, ensure an empty vector comes back @@ -3206,12 +3576,71 @@ class Context return CL_SUCCESS; } -}; -inline void Device::makeDefault() -{ - /* Throwing an exception from a call_once invocation does not do - * what we wish, so we catch it and save the error. +#if defined(cl_ext_image_requirements_info) + template + cl_int getImageRequirementsInfoExt(cl_image_requirements_info_ext name, + T* param, + cl_mem_flags flags = 0, + const cl_mem_properties* properties = nullptr, + const ImageFormat* image_format = nullptr, + const cl_image_desc* image_desc = nullptr) const + { + ImageRequirementsInfo imageInfo = {flags, properties, image_format, image_desc}; + + return detail::errHandler( + detail::getInfo( + Context::getImageRequirementsInfoExtHelper, *this, imageInfo, name, param), + __GET_IMAGE_REQUIREMENT_INFO_EXT_ERR); + } + + template typename + detail::param_traits::param_type + getImageRequirementsInfoExt(cl_mem_flags flags = 0, + const cl_mem_properties* properties = nullptr, + const ImageFormat* image_format = nullptr, + const cl_image_desc* image_desc = nullptr, + cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_image_requirements_info_ext, type>::param_type param; + cl_int result = getImageRequirementsInfoExt(type, ¶m, flags, properties, image_format, image_desc); + if (err != nullptr) { + *err = result; + } + return param; + } +#endif // cl_ext_image_requirements_info + +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Registers a destructor callback function with a context. + * + * Wraps clSetContextDestructorCallback(). + * + * Each call to this function registers the specified callback function on + * a destructor callback stack associated with context. The registered + * callback functions are called in the reverse order in which they were registered. + * If a context callback function was specified when context was created, + * it will not be called after any context destructor callback is called. + */ + cl_int setDestructorCallback( + void (CL_CALLBACK * pfn_notify)(cl_context, void *), + void * user_data = nullptr) + { + return detail::errHandler( + ::clSetContextDestructorCallback( + object_, + pfn_notify, + user_data), + __SET_CONTEXT_DESCTRUCTOR_CALLBACK_ERR); + } +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 +}; + +inline void Device::makeDefault() +{ + /* Throwing an exception from a call_once invocation does not do + * what we wish, so we catch it and save the error. */ #if defined(CL_HPP_ENABLE_EXCEPTIONS) try @@ -3252,7 +3681,7 @@ CL_HPP_DEFINE_STATIC_MEMBER_ cl_int Context::default_error_ = CL_SUCCESS; class Event : public detail::Wrapper { public: - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Event() : detail::Wrapper() { } /*! \brief Constructor from cl_event - takes ownership. @@ -3289,12 +3718,12 @@ class Event : public detail::Wrapper //! \brief Wrapper for clGetEventInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_event_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -3312,12 +3741,12 @@ class Event : public detail::Wrapper //! \brief Wrapper for clGetEventProfilingInfo() that returns by value. template typename detail::param_traits::param_type - getProfilingInfo(cl_int* err = NULL) const + getProfilingInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_profiling_info, name>::param_type param; cl_int result = getProfilingInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -3342,7 +3771,7 @@ class Event : public detail::Wrapper cl_int setCallback( cl_int type, void (CL_CALLBACK * pfn_notify)(cl_event, cl_int, void *), - void * user_data = NULL) + void * user_data = nullptr) { return detail::errHandler( ::clSetEventCallback( @@ -3361,9 +3790,12 @@ class Event : public detail::Wrapper static cl_int waitForEvents(const vector& events) { + static_assert(sizeof(cl::Event) == sizeof(cl_event), + "Size of cl::Event must be equal to size of cl_event"); + return detail::errHandler( ::clWaitForEvents( - (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : NULL), + (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : nullptr), __WAIT_FOR_EVENTS_ERR); } }; @@ -3382,7 +3814,7 @@ class UserEvent : public Event */ UserEvent( const Context& context, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateUserEvent( @@ -3390,12 +3822,12 @@ class UserEvent : public Event &error); detail::errHandler(error, __CREATE_USER_EVENT_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. UserEvent() : Event() { } /*! \brief Sets the execution status of a user event object. @@ -3420,7 +3852,7 @@ WaitForEvents(const vector& events) { return detail::errHandler( ::clWaitForEvents( - (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : NULL), + (cl_uint) events.size(), (events.size() > 0) ? (cl_event*)&events.front() : nullptr), __WAIT_FOR_EVENTS_ERR); } @@ -3435,7 +3867,7 @@ WaitForEvents(const vector& events) class Memory : public detail::Wrapper { public: - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Memory() : detail::Wrapper() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -3463,35 +3895,6 @@ class Memory : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Memory(const Memory& mem) : detail::Wrapper(mem) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Memory& operator = (const Memory &mem) - { - detail::Wrapper::operator=(mem); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Memory(Memory&& mem) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(mem)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Memory& operator = (Memory &&mem) - { - detail::Wrapper::operator=(std::move(mem)); - return *this; - } - - //! \brief Wrapper for clGetMemObjectInfo(). template cl_int getInfo(cl_mem_info name, T* param) const @@ -3504,12 +3907,12 @@ class Memory : public detail::Wrapper //! \brief Wrapper for clGetMemObjectInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_mem_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -3531,7 +3934,7 @@ class Memory : public detail::Wrapper */ cl_int setDestructorCallback( void (CL_CALLBACK * pfn_notify)(cl_mem, void *), - void * user_data = NULL) + void * user_data = nullptr) { return detail::errHandler( ::clSetMemObjectDestructorCallback( @@ -3643,8 +4046,8 @@ inline cl_int enqueueMapSVM( cl_bool blocking, cl_map_flags flags, size_type size, - const vector* events = NULL, - Event* event = NULL); + const vector* events = nullptr, + Event* event = nullptr); /** * STL-like allocator class for managing SVM objects provided for convenience. @@ -3706,12 +4109,12 @@ class SVMAllocator { { } - pointer address(reference r) CL_HPP_NOEXCEPT_ + pointer address(reference r) noexcept { return std::addressof(r); } - const_pointer address(const_reference r) CL_HPP_NOEXCEPT_ + const_pointer address(const_reference r) noexcept { return std::addressof(r); } @@ -3724,7 +4127,8 @@ class SVMAllocator { */ pointer allocate( size_type size, - typename cl::SVMAllocator::const_pointer = 0) + typename cl::SVMAllocator::const_pointer = 0, + bool map = true) { // Allocate memory with default alignment matching the size of the type void* voidPointer = @@ -3743,11 +4147,15 @@ class SVMAllocator { #endif // #if defined(CL_HPP_ENABLE_EXCEPTIONS) // If allocation was coarse-grained then map it - if (!(SVMTrait::getSVMMemFlags() & CL_MEM_SVM_FINE_GRAIN_BUFFER)) { + if (map && !(SVMTrait::getSVMMemFlags() & CL_MEM_SVM_FINE_GRAIN_BUFFER)) { cl_int err = enqueueMapSVM(retValue, CL_TRUE, CL_MAP_READ | CL_MAP_WRITE, size*sizeof(T)); if (err != CL_SUCCESS) { + clSVMFree(context_(), retValue); + retValue = nullptr; +#if defined(CL_HPP_ENABLE_EXCEPTIONS) std::bad_alloc excep; throw excep; +#endif } } @@ -3764,7 +4172,7 @@ class SVMAllocator { * Return the maximum possible allocation size. * This is the minimum of the maximum sizes of all devices in the context. */ - size_type max_size() const CL_HPP_NOEXCEPT_ + size_type max_size() const noexcept { size_type maxSize = std::numeric_limits::max() / sizeof(T); @@ -3862,10 +4270,18 @@ cl::pointer> allocate_pointer(const Alloc &alloc_, Arg T* tmp = std::allocator_traits::allocate(alloc, copies); if (!tmp) { +#if defined(CL_HPP_ENABLE_EXCEPTIONS) std::bad_alloc excep; throw excep; +#else + return nullptr; +#endif } - try { + +#if defined(CL_HPP_ENABLE_EXCEPTIONS) + try +#endif + { std::allocator_traits::construct( alloc, std::addressof(*tmp), @@ -3873,11 +4289,13 @@ cl::pointer> allocate_pointer(const Alloc &alloc_, Arg return cl::pointer>(tmp, detail::Deleter{alloc, copies}); } - catch (std::bad_alloc& b) +#if defined(CL_HPP_ENABLE_EXCEPTIONS) + catch (std::bad_alloc&) { std::allocator_traits::deallocate(alloc, tmp, copies); throw; } +#endif } template< class T, class SVMTrait, class... Args > @@ -3937,44 +4355,90 @@ class Buffer : public Memory const Context& context, cl_mem_flags flags, size_type size, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error); detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - /*! \brief Constructs a Buffer in the default context. +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Buffer in a specified context and with specified properties. * - * Wraps clCreateBuffer(). + * Wraps clCreateBufferWithProperties(). * + * \param properties Optional list of properties for the buffer object and + * their corresponding values. The non-empty list must + * end with 0. * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was - * specified. Note alignment & exclusivity requirements. - * - * \see Context::getDefault() + * specified. Note alignment & exclusivity requirements. */ Buffer( - cl_mem_flags flags, + const Context& context, + const vector& properties, + cl_mem_flags flags, size_type size, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; - Context context = Context::getDefault(err); - - object_ = ::clCreateBuffer(context(), flags, size, host_ptr, &error); + if (properties.empty()) { + object_ = ::clCreateBufferWithProperties(context(), nullptr, flags, + size, host_ptr, &error); + } + else { + object_ = ::clCreateBufferWithProperties( + context(), properties.data(), flags, size, host_ptr, &error); + } detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } +#endif + + /*! \brief Constructs a Buffer in the default context. + * + * Wraps clCreateBuffer(). + * + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + * + * \see Context::getDefault() + */ + Buffer( + cl_mem_flags flags, + size_type size, + void* host_ptr = nullptr, + cl_int* err = nullptr) : Buffer(Context::getDefault(err), flags, size, host_ptr, err) { } + +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Buffer in the default context and with specified properties. + * + * Wraps clCreateBufferWithProperties(). + * + * \param properties Optional list of properties for the buffer object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + * + * \see Context::getDefault() + */ + Buffer( + const vector& properties, + cl_mem_flags flags, + size_type size, + void* host_ptr = nullptr, + cl_int* err = nullptr) : Buffer(Context::getDefault(err), properties, flags, size, host_ptr, err) { } +#endif /*! * \brief Construct a Buffer from a host container via iterators. @@ -3987,7 +4451,7 @@ class Buffer : public Memory IteratorType endIterator, bool readOnly, bool useHostPtr = false, - cl_int* err = NULL) + cl_int* err = nullptr) { typedef typename std::iterator_traits::value_type DataType; cl_int error; @@ -4014,14 +4478,14 @@ class Buffer : public Memory } detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } if( !useHostPtr ) { error = cl::copy(startIterator, endIterator, *this); detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -4034,7 +4498,7 @@ class Buffer : public Memory */ template< typename IteratorType > Buffer(const Context &context, IteratorType startIterator, IteratorType endIterator, - bool readOnly, bool useHostPtr = false, cl_int* err = NULL); + bool readOnly, bool useHostPtr = false, cl_int* err = nullptr); /*! * \brief Construct a Buffer from a host container via iterators using a specified queue. @@ -4042,9 +4506,9 @@ class Buffer : public Memory */ template< typename IteratorType > Buffer(const CommandQueue &queue, IteratorType startIterator, IteratorType endIterator, - bool readOnly, bool useHostPtr = false, cl_int* err = NULL); + bool readOnly, bool useHostPtr = false, cl_int* err = nullptr); - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Buffer() : Memory() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4067,33 +4531,6 @@ class Buffer : public Memory return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Buffer(const Buffer& buf) : Memory(buf) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Buffer& operator = (const Buffer &buf) - { - Memory::operator=(buf); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Buffer(Buffer&& buf) CL_HPP_NOEXCEPT_ : Memory(std::move(buf)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Buffer& operator = (Buffer &&buf) - { - Memory::operator=(std::move(buf)); - return *this; - } #if CL_HPP_TARGET_OPENCL_VERSION >= 110 /*! \brief Creates a new buffer object from this. @@ -4104,7 +4541,7 @@ class Buffer : public Memory cl_mem_flags flags, cl_buffer_create_type buffer_create_type, const void * buffer_create_info, - cl_int * err = NULL) + cl_int * err = nullptr) { Buffer result; cl_int error; @@ -4116,7 +4553,7 @@ class Buffer : public Memory &error); detail::errHandler(error, __CREATE_SUBBUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } @@ -4148,7 +4585,7 @@ class BufferD3D10 : public Buffer const Context& context, cl_mem_flags flags, ID3D10Buffer* bufobj, - cl_int * err = NULL) : pfn_clCreateFromD3D10BufferKHR(nullptr) + cl_int * err = nullptr) : pfn_clCreateFromD3D10BufferKHR(nullptr) { typedef CL_API_ENTRY cl_mem (CL_API_CALL *PFN_clCreateFromD3D10BufferKHR)( cl_context context, cl_mem_flags flags, ID3D10Buffer* buffer, @@ -4156,14 +4593,15 @@ class BufferD3D10 : public Buffer PFN_clCreateFromD3D10BufferKHR pfn_clCreateFromD3D10BufferKHR; #if CL_HPP_TARGET_OPENCL_VERSION >= 120 vector props = context.getInfo(); - cl_platform platform = -1; + cl_platform platform = nullptr; for( int i = 0; i < props.size(); ++i ) { if( props[i] == CL_CONTEXT_PLATFORM ) { platform = props[i+1]; } } CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCreateFromD3D10BufferKHR); -#elif CL_HPP_TARGET_OPENCL_VERSION >= 110 +#endif +#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateFromD3D10BufferKHR); #endif @@ -4174,13 +4612,14 @@ class BufferD3D10 : public Buffer bufobj, &error); + // TODO: This should really have a D3D10 rerror code! detail::errHandler(error, __CREATE_GL_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. BufferD3D10() : Buffer() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4202,35 +4641,6 @@ class BufferD3D10 : public Buffer Buffer::operator=(rhs); return *this; } - - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferD3D10(const BufferD3D10& buf) : - Buffer(buf) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferD3D10& operator = (const BufferD3D10 &buf) - { - Buffer::operator=(buf); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferD3D10(BufferD3D10&& buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferD3D10& operator = (BufferD3D10 &&buf) - { - Buffer::operator=(std::move(buf)); - return *this; - } }; #endif @@ -4254,7 +4664,7 @@ class BufferGL : public Buffer const Context& context, cl_mem_flags flags, cl_GLuint bufobj, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateFromGLBuffer( @@ -4264,12 +4674,12 @@ class BufferGL : public Buffer &error); detail::errHandler(error, __CREATE_GL_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. BufferGL() : Buffer() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4292,33 +4702,6 @@ class BufferGL : public Buffer return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferGL(const BufferGL& buf) : Buffer(buf) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferGL& operator = (const BufferGL &buf) - { - Buffer::operator=(buf); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferGL(BufferGL&& buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferGL& operator = (BufferGL &&buf) - { - Buffer::operator=(std::move(buf)); - return *this; - } //! \brief Wrapper for clGetGLObjectInfo(). cl_int getObjectInfo( @@ -4351,7 +4734,7 @@ class BufferRenderGL : public Buffer const Context& context, cl_mem_flags flags, cl_GLuint bufobj, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateFromGLRenderbuffer( @@ -4361,12 +4744,12 @@ class BufferRenderGL : public Buffer &error); detail::errHandler(error, __CREATE_GL_RENDER_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. BufferRenderGL() : Buffer() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4389,33 +4772,6 @@ class BufferRenderGL : public Buffer return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferRenderGL(const BufferRenderGL& buf) : Buffer(buf) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - BufferRenderGL& operator = (const BufferRenderGL &buf) - { - Buffer::operator=(buf); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferRenderGL(BufferRenderGL&& buf) CL_HPP_NOEXCEPT_ : Buffer(std::move(buf)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - BufferRenderGL& operator = (BufferRenderGL &&buf) - { - Buffer::operator=(std::move(buf)); - return *this; - } //! \brief Wrapper for clGetGLObjectInfo(). cl_int getObjectInfo( @@ -4437,7 +4793,7 @@ class BufferRenderGL : public Buffer class Image : public Memory { protected: - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Image() : Memory() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4460,34 +4816,6 @@ class Image : public Memory return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image(const Image& img) : Memory(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image& operator = (const Image &img) - { - Memory::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image(Image&& img) CL_HPP_NOEXCEPT_ : Memory(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image& operator = (Image &&img) - { - Memory::operator=(std::move(img)); - return *this; - } - public: //! \brief Wrapper for clGetImageInfo(). @@ -4502,12 +4830,12 @@ class Image : public Memory //! \brief Wrapper for clGetImageInfo() that returns by value. template typename detail::param_traits::param_type - getImageInfo(cl_int* err = NULL) const + getImageInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_image_info, name>::param_type param; cl_int result = getImageInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -4533,12 +4861,12 @@ class Image1D : public Image cl_mem_flags flags, ImageFormat format, size_type width, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE1D; desc.image_width = width; @@ -4551,14 +4879,50 @@ class Image1D : public Image &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Image1D() { } +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image1D with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + */ + Image1D(const Context &context, const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type width, + void *host_ptr = nullptr, cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE1D; + desc.image_width = width; + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, host_ptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, host_ptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructor from cl_mem - takes ownership. * * \param retainObject will cause the constructor to retain its cl object. @@ -4579,33 +4943,6 @@ class Image1D : public Image return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1D(const Image1D& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1D& operator = (const Image1D &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1D(Image1D&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1D& operator = (Image1D &&img) - { - Image::operator=(std::move(img)); - return *this; - } }; @@ -4621,11 +4958,11 @@ class Image1DBuffer : public Image ImageFormat format, size_type width, const Buffer &buffer, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER; desc.image_width = width; desc.buffer = buffer(); @@ -4635,17 +4972,54 @@ class Image1DBuffer : public Image flags, &format, &desc, - NULL, + nullptr, &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } Image1DBuffer() { } +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image1DBuffer with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param buffer Refer to a valid buffer or image memory object. + */ + Image1DBuffer(const Context &context, + const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type width, + const Buffer &buffer, cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE1D_BUFFER; + desc.image_width = width; + desc.buffer = buffer(); + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, nullptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, nullptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructor from cl_mem - takes ownership. * * \param retainObject will cause the constructor to retain its cl object. @@ -4661,35 +5035,6 @@ class Image1DBuffer : public Image Image::operator=(rhs); return *this; } - - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1DBuffer(const Image1DBuffer& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1DBuffer& operator = (const Image1DBuffer &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1DBuffer(Image1DBuffer&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1DBuffer& operator = (Image1DBuffer &&img) - { - Image::operator=(std::move(img)); - return *this; - } - }; /*! \class Image1DArray @@ -4705,12 +5050,12 @@ class Image1DArray : public Image size_type arraySize, size_type width, size_type rowPitch, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE1D_ARRAY; desc.image_width = width; desc.image_array_size = arraySize; @@ -4725,13 +5070,53 @@ class Image1DArray : public Image &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } Image1DArray() { } - + +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image1DArray with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + */ + Image1DArray(const Context &context, + const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type arraySize, + size_type width, size_type rowPitch = 0, + void *host_ptr = nullptr, cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE1D_ARRAY; + desc.image_width = width; + desc.image_array_size = arraySize; + desc.image_row_pitch = rowPitch; + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, host_ptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, host_ptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructor from cl_mem - takes ownership. * * \param retainObject will cause the constructor to retain its cl object. @@ -4749,33 +5134,6 @@ class Image1DArray : public Image return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1DArray(const Image1DArray& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image1DArray& operator = (const Image1DArray &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1DArray(Image1DArray&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image1DArray& operator = (Image1DArray &&img) - { - Image::operator=(std::move(img)); - return *this; - } }; #endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 120 @@ -4801,8 +5159,8 @@ class Image2D : public Image size_type width, size_type height, size_type row_pitch = 0, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; bool useCreateImage; @@ -4822,7 +5180,7 @@ class Image2D : public Image #if CL_HPP_TARGET_OPENCL_VERSION >= 120 if (useCreateImage) { - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE2D; desc.image_width = width; desc.image_height = height; @@ -4837,7 +5195,7 @@ class Image2D : public Image &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -4849,17 +5207,20 @@ class Image2D : public Image context(), flags,&format, width, height, row_pitch, host_ptr, &error); detail::errHandler(error, __CREATE_IMAGE2D_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } #endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120 } -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 || defined(CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR) +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 /*! \brief Constructs a 2D Image from a buffer. * \note This will share storage with the underlying buffer. * + * Requires OpenCL 2.0 or newer or OpenCL 1.2 and the + * cl_khr_image2d_from_buffer extension. + * * Wraps clCreateImage(). */ Image2D( @@ -4873,7 +5234,7 @@ class Image2D : public Image { cl_int error; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE2D; desc.image_width = width; desc.image_height = height; @@ -4893,7 +5254,7 @@ class Image2D : public Image *err = error; } } -#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 200 || defined(CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR) +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 #if CL_HPP_TARGET_OPENCL_VERSION >= 200 /*! \brief Constructs a 2D Image from an image. @@ -4934,7 +5295,7 @@ class Image2D : public Image // Channel format inherited from source. sourceFormat.image_channel_order = order; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE2D; desc.image_width = sourceWidth; desc.image_height = sourceHeight; @@ -4958,7 +5319,84 @@ class Image2D : public Image } #endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - //! \brief Default constructor - initializes to NULL. +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image2D with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + */ + Image2D(const Context &context, const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type width, + size_type height, size_type row_pitch = 0, void *host_ptr = nullptr, + cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE2D; + desc.image_width = width; + desc.image_height = height; + desc.image_row_pitch = row_pitch; + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, host_ptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, host_ptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } + + /*! \brief Constructs a Image2D with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param buffer Refer to a valid buffer or image memory object. + */ + Image2D(const Context &context, const vector &properties, + cl_mem_flags flags, ImageFormat format, const Buffer &buffer, + size_type width, size_type height, size_type row_pitch = 0, + cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE2D; + desc.image_width = width; + desc.image_height = height; + desc.image_row_pitch = row_pitch; + desc.buffer = buffer(); + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, nullptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, nullptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } + +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + + //! \brief Default constructor - initializes to nullptr. Image2D() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -4980,35 +5418,6 @@ class Image2D : public Image Image::operator=(rhs); return *this; } - - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2D(const Image2D& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2D& operator = (const Image2D &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2D(Image2D&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2D& operator = (Image2D &&img) - { - Image::operator=(std::move(img)); - return *this; - } - }; @@ -5036,7 +5445,7 @@ class CL_API_PREFIX__VERSION_1_1_DEPRECATED Image2DGL : public Image2D cl_GLenum target, cl_GLint miplevel, cl_GLuint texobj, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateFromGLTexture2D( @@ -5048,13 +5457,13 @@ class CL_API_PREFIX__VERSION_1_1_DEPRECATED Image2DGL : public Image2D &error); detail::errHandler(error, __CREATE_GL_TEXTURE_2D_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Image2DGL() : Image2D() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -5077,33 +5486,7 @@ class CL_API_PREFIX__VERSION_1_1_DEPRECATED Image2DGL : public Image2D return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2DGL(const Image2DGL& img) : Image2D(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2DGL& operator = (const Image2DGL &img) - { - Image2D::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2DGL(Image2DGL&& img) CL_HPP_NOEXCEPT_ : Image2D(std::move(img)) {} - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2DGL& operator = (Image2DGL &&img) - { - Image2D::operator=(std::move(img)); - return *this; - } } CL_API_SUFFIX__VERSION_1_1_DEPRECATED; #endif // CL_USE_DEPRECATED_OPENCL_1_1_APIS @@ -5124,12 +5507,12 @@ class Image2DArray : public Image size_type height, size_type rowPitch, size_type slicePitch, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY; desc.image_width = width; desc.image_height = height; @@ -5146,11 +5529,54 @@ class Image2DArray : public Image &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image2DArray with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + */ + Image2DArray(const Context &context, + const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type arraySize, + size_type width, size_type height, size_type rowPitch = 0, + size_type slicePitch = 0, void *host_ptr = nullptr, + cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE2D_ARRAY; + desc.image_width = width; + desc.image_height = height; + desc.image_array_size = arraySize; + desc.image_row_pitch = rowPitch; + desc.image_slice_pitch = slicePitch; + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, host_ptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, host_ptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + Image2DArray() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -5168,33 +5594,6 @@ class Image2DArray : public Image return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2DArray(const Image2DArray& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image2DArray& operator = (const Image2DArray &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2DArray(Image2DArray&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image2DArray& operator = (Image2DArray &&img) - { - Image::operator=(std::move(img)); - return *this; - } }; #endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 120 @@ -5220,8 +5619,8 @@ class Image3D : public Image size_type depth, size_type row_pitch = 0, size_type slice_pitch = 0, - void* host_ptr = NULL, - cl_int* err = NULL) + void* host_ptr = nullptr, + cl_int* err = nullptr) { cl_int error; bool useCreateImage; @@ -5241,7 +5640,7 @@ class Image3D : public Image #if CL_HPP_TARGET_OPENCL_VERSION >= 120 if (useCreateImage) { - cl_image_desc desc = {0}; + cl_image_desc desc = {}; desc.image_type = CL_MEM_OBJECT_IMAGE3D; desc.image_width = width; desc.image_height = height; @@ -5258,7 +5657,7 @@ class Image3D : public Image &error); detail::errHandler(error, __CREATE_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -5271,14 +5670,56 @@ class Image3D : public Image slice_pitch, host_ptr, &error); detail::errHandler(error, __CREATE_IMAGE3D_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } #endif // CL_HPP_MINIMUM_OPENCL_VERSION < 120 } - //! \brief Default constructor - initializes to NULL. +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + /*! \brief Constructs a Image3D with specified properties. + * + * Wraps clCreateImageWithProperties(). + * + * \param properties Optional list of properties for the image object and + * their corresponding values. The non-empty list must + * end with 0. + * \param host_ptr Storage to be used if the CL_MEM_USE_HOST_PTR flag was + * specified. Note alignment & exclusivity requirements. + */ + Image3D(const Context &context, const vector &properties, + cl_mem_flags flags, ImageFormat format, size_type width, + size_type height, size_type depth, size_type row_pitch = 0, + size_type slice_pitch = 0, void *host_ptr = nullptr, + cl_int *err = nullptr) { + cl_int error; + + cl_image_desc desc = {}; + desc.image_type = CL_MEM_OBJECT_IMAGE3D; + desc.image_width = width; + desc.image_height = height; + desc.image_depth = depth; + desc.image_row_pitch = row_pitch; + desc.image_slice_pitch = slice_pitch; + + if (properties.empty()) { + object_ = ::clCreateImageWithProperties( + context(), nullptr, flags, &format, &desc, host_ptr, &error); + } else { + object_ = + ::clCreateImageWithProperties(context(), properties.data(), flags, + &format, &desc, host_ptr, &error); + } + + detail::errHandler(error, __CREATE_IMAGE_ERR); + if (err != nullptr) { + *err = error; + } + } +#endif //#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + + //! \brief Default constructor - initializes to nullptr. Image3D() : Image() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -5301,33 +5742,6 @@ class Image3D : public Image return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image3D(const Image3D& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image3D& operator = (const Image3D &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image3D(Image3D&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image3D& operator = (Image3D &&img) - { - Image::operator=(std::move(img)); - return *this; - } }; #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) @@ -5353,7 +5767,7 @@ class Image3DGL : public Image3D cl_GLenum target, cl_GLint miplevel, cl_GLuint texobj, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateFromGLTexture3D( @@ -5365,12 +5779,12 @@ class Image3DGL : public Image3D &error); detail::errHandler(error, __CREATE_GL_TEXTURE_3D_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Image3DGL() : Image3D() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -5393,33 +5807,6 @@ class Image3DGL : public Image3D return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image3DGL(const Image3DGL& img) : Image3D(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Image3DGL& operator = (const Image3DGL &img) - { - Image3D::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Image3DGL(Image3DGL&& img) CL_HPP_NOEXCEPT_ : Image3D(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Image3DGL& operator = (Image3DGL &&img) - { - Image3D::operator=(std::move(img)); - return *this; - } }; #endif // CL_USE_DEPRECATED_OPENCL_1_1_APIS @@ -5439,7 +5826,7 @@ class ImageGL : public Image cl_GLenum target, cl_GLint miplevel, cl_GLuint texobj, - cl_int * err = NULL) + cl_int * err = nullptr) { cl_int error; object_ = ::clCreateFromGLTexture( @@ -5451,7 +5838,7 @@ class ImageGL : public Image &error); detail::errHandler(error, __CREATE_GL_TEXTURE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -5474,33 +5861,6 @@ class ImageGL : public Image return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - ImageGL(const ImageGL& img) : Image(img) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - ImageGL& operator = (const ImageGL &img) - { - Image::operator=(img); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - ImageGL(ImageGL&& img) CL_HPP_NOEXCEPT_ : Image(std::move(img)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - ImageGL& operator = (ImageGL &&img) - { - Image::operator=(std::move(img)); - return *this; - } }; #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 @@ -5530,7 +5890,7 @@ class Pipe : public Memory const Context& context, cl_uint packet_size, cl_uint max_packets, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -5538,7 +5898,7 @@ class Pipe : public Memory object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error); detail::errHandler(error, __CREATE_PIPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -5554,7 +5914,7 @@ class Pipe : public Memory Pipe( cl_uint packet_size, cl_uint max_packets, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -5564,12 +5924,12 @@ class Pipe : public Memory object_ = ::clCreatePipe(context(), flags, packet_size, max_packets, nullptr, &error); detail::errHandler(error, __CREATE_PIPE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Pipe() : Memory() { } /*! \brief Constructor from cl_mem - takes ownership. @@ -5592,33 +5952,7 @@ class Pipe : public Memory return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Pipe(const Pipe& pipe) : Memory(pipe) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Pipe& operator = (const Pipe &pipe) - { - Memory::operator=(pipe); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Pipe(Pipe&& pipe) CL_HPP_NOEXCEPT_ : Memory(std::move(pipe)) {} - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Pipe& operator = (Pipe &&pipe) - { - Memory::operator=(std::move(pipe)); - return *this; - } //! \brief Wrapper for clGetMemObjectInfo(). template @@ -5632,12 +5966,12 @@ class Pipe : public Memory //! \brief Wrapper for clGetMemObjectInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_pipe_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -5657,7 +5991,7 @@ class Pipe : public Memory class Sampler : public detail::Wrapper { public: - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Sampler() { } /*! \brief Constructs a Sampler in a specified context. @@ -5669,7 +6003,7 @@ class Sampler : public detail::Wrapper cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -5685,7 +6019,7 @@ class Sampler : public detail::Wrapper &error); detail::errHandler(error, __CREATE_SAMPLER_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } #else @@ -5697,7 +6031,7 @@ class Sampler : public detail::Wrapper &error); detail::errHandler(error, __CREATE_SAMPLER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } #endif @@ -5725,33 +6059,7 @@ class Sampler : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Sampler(const Sampler& sam) : detail::Wrapper(sam) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Sampler& operator = (const Sampler &sam) - { - detail::Wrapper::operator=(sam); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Sampler(Sampler&& sam) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(sam)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Sampler& operator = (Sampler &&sam) - { - detail::Wrapper::operator=(std::move(sam)); - return *this; - } + //! \brief Wrapper for clGetSamplerInfo(). template @@ -5765,12 +6073,12 @@ class Sampler : public detail::Wrapper //! \brief Wrapper for clGetSamplerInfo() that returns by value. template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_sampler_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -5826,6 +6134,15 @@ class NDRange sizes_[2] = size2; } + //! \brief Constructs one-dimensional range. + NDRange(array a) : NDRange(a[0]){} + + //! \brief Constructs two-dimensional range. + NDRange(array a) : NDRange(a[0], a[1]){} + + //! \brief Constructs three-dimensional range. + NDRange(array a) : NDRange(a[0], a[1], a[2]){} + /*! \brief Conversion operator to const size_type *. * * \returns a pointer to the size of the first dimension. @@ -5896,7 +6213,7 @@ template <> struct KernelArgumentHandler { static size_type size(const LocalSpaceArg& value) { return value.size_; } - static const void* ptr(const LocalSpaceArg&) { return NULL; } + static const void* ptr(const LocalSpaceArg&) { return nullptr; } }; } @@ -5923,9 +6240,10 @@ Local(size_type size) class Kernel : public detail::Wrapper { public: - inline Kernel(const Program& program, const char* name, cl_int* err = NULL); + inline Kernel(const Program& program, const string& name, cl_int* err = nullptr); + inline Kernel(const Program& program, const char* name, cl_int* err = nullptr); - //! \brief Default constructor - initializes to NULL. + //! \brief Default constructor - initializes to nullptr. Kernel() { } /*! \brief Constructor from cl_kernel - takes ownership. @@ -5950,33 +6268,8 @@ class Kernel : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Kernel(const Kernel& kernel) : detail::Wrapper(kernel) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Kernel& operator = (const Kernel &kernel) - { - detail::Wrapper::operator=(kernel); - return *this; - } - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Kernel(Kernel&& kernel) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(kernel)) {} - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Kernel& operator = (Kernel &&kernel) - { - detail::Wrapper::operator=(std::move(kernel)); - return *this; - } template cl_int getInfo(cl_kernel_info name, T* param) const @@ -5988,12 +6281,12 @@ class Kernel : public detail::Wrapper template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_kernel_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -6010,12 +6303,12 @@ class Kernel : public detail::Wrapper template typename detail::param_traits::param_type - getArgInfo(cl_uint argIndex, cl_int* err = NULL) const + getArgInfo(cl_uint argIndex, cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_kernel_arg_info, name>::param_type param; cl_int result = getArgInfo(argIndex, name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -6034,18 +6327,18 @@ class Kernel : public detail::Wrapper template typename detail::param_traits::param_type - getWorkGroupInfo(const Device& device, cl_int* err = NULL) const + getWorkGroupInfo(const Device& device, cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_kernel_work_group_info, name>::param_type param; cl_int result = getWorkGroupInfo(device, name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; } -#if (CL_HPP_TARGET_OPENCL_VERSION >= 200 && defined(CL_HPP_USE_CL_SUB_GROUPS_KHR)) || CL_HPP_TARGET_OPENCL_VERSION >= 210 +#if defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) || CL_HPP_TARGET_OPENCL_VERSION >= 210 cl_int getSubGroupInfo(const cl::Device &dev, cl_kernel_sub_group_info name, const cl::NDRange &range, size_type* param) const { #if CL_HPP_TARGET_OPENCL_VERSION >= 210 @@ -6057,7 +6350,7 @@ class Kernel : public detail::Wrapper #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210 typedef clGetKernelSubGroupInfoKHR_fn PFN_clGetKernelSubGroupInfoKHR; - static PFN_clGetKernelSubGroupInfoKHR pfn_clGetKernelSubGroupInfoKHR = NULL; + static PFN_clGetKernelSubGroupInfoKHR pfn_clGetKernelSubGroupInfoKHR = nullptr; CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetKernelSubGroupInfoKHR); return detail::errHandler( @@ -6068,16 +6361,16 @@ class Kernel : public detail::Wrapper } template - size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &range, cl_int* err = NULL) const + size_type getSubGroupInfo(const cl::Device &dev, const cl::NDRange &range, cl_int* err = nullptr) const { size_type param; cl_int result = getSubGroupInfo(dev, name, range, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; } -#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 +#endif // defined(CL_HPP_USE_CL_SUB_GROUPS_KHR) || CL_HPP_TARGET_OPENCL_VERSION >= 210 #if CL_HPP_TARGET_OPENCL_VERSION >= 200 /*! \brief setArg overload taking a shared_ptr type @@ -6283,7 +6576,7 @@ class Program : public detail::Wrapper Program( const string& source, bool build = false, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6302,19 +6595,19 @@ class Program : public detail::Wrapper error = ::clBuildProgram( object_, 0, - NULL, + nullptr, #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) "-cl-std=CL2.0", #else "", #endif // #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) - NULL, - NULL); + nullptr, + nullptr); detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo()); } - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6323,7 +6616,7 @@ class Program : public detail::Wrapper const Context& context, const string& source, bool build = false, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6339,19 +6632,19 @@ class Program : public detail::Wrapper error = ::clBuildProgram( object_, 0, - NULL, + nullptr, #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) "-cl-std=CL2.0", #else "", #endif // #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) - NULL, - NULL); + nullptr, + nullptr); detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo()); } - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6362,7 +6655,7 @@ class Program : public detail::Wrapper */ Program( const Sources& sources, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; Context context = Context::getDefault(err); @@ -6386,7 +6679,7 @@ class Program : public detail::Wrapper context(), (cl_uint)n, strings.data(), lengths.data(), &error); detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6398,7 +6691,7 @@ class Program : public detail::Wrapper Program( const Context& context, const Sources& sources, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6421,21 +6714,21 @@ class Program : public detail::Wrapper context(), (cl_uint)n, strings.data(), lengths.data(), &error); detail::errHandler(error, __CREATE_PROGRAM_WITH_SOURCE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } - -#if CL_HPP_TARGET_OPENCL_VERSION >= 210 || (CL_HPP_TARGET_OPENCL_VERSION==200 && defined(CL_HPP_USE_IL_KHR)) +#if defined(CL_HPP_USE_IL_KHR) || CL_HPP_TARGET_OPENCL_VERSION >= 210 /** * Program constructor to allow construction of program from SPIR-V or another IL. - * Valid for either OpenCL >= 2.1 or when CL_HPP_USE_IL_KHR is defined. + * + * Requires OpenCL 2.1 or newer or the cl_khr_il_program extension. */ Program( const vector& IL, bool build = false, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6449,7 +6742,7 @@ class Program : public detail::Wrapper #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210 typedef clCreateProgramWithILKHR_fn PFN_clCreateProgramWithILKHR; - static PFN_clCreateProgramWithILKHR pfn_clCreateProgramWithILKHR = NULL; + static PFN_clCreateProgramWithILKHR pfn_clCreateProgramWithILKHR = nullptr; CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateProgramWithILKHR); object_ = pfn_clCreateProgramWithILKHR( @@ -6464,19 +6757,19 @@ class Program : public detail::Wrapper error = ::clBuildProgram( object_, 0, - NULL, + nullptr, #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) "-cl-std=CL2.0", #else "", #endif // #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) - NULL, - NULL); + nullptr, + nullptr); detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo()); } - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6484,13 +6777,14 @@ class Program : public detail::Wrapper /** * Program constructor to allow construction of program from SPIR-V or another IL * for a specific context. - * Valid for either OpenCL >= 2.1 or when CL_HPP_USE_IL_KHR is defined. + * + * Requires OpenCL 2.1 or newer or the cl_khr_il_program extension. */ Program( const Context& context, const vector& IL, bool build = false, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6502,7 +6796,7 @@ class Program : public detail::Wrapper #else // #if CL_HPP_TARGET_OPENCL_VERSION >= 210 typedef clCreateProgramWithILKHR_fn PFN_clCreateProgramWithILKHR; - static PFN_clCreateProgramWithILKHR pfn_clCreateProgramWithILKHR = NULL; + static PFN_clCreateProgramWithILKHR pfn_clCreateProgramWithILKHR = nullptr; CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateProgramWithILKHR); object_ = pfn_clCreateProgramWithILKHR( @@ -6516,23 +6810,23 @@ class Program : public detail::Wrapper error = ::clBuildProgram( object_, 0, - NULL, + nullptr, #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) "-cl-std=CL2.0", #else "", #endif // #if !defined(CL_HPP_CL_1_2_DEFAULT_BUILD) - NULL, - NULL); + nullptr, + nullptr); detail::buildErrHandler(error, __BUILD_PROGRAM_ERR, getBuildInfo()); } - if (err != NULL) { + if (err != nullptr) { *err = error; } } -#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 210 +#endif // defined(CL_HPP_USE_IL_KHR) || CL_HPP_TARGET_OPENCL_VERSION >= 210 /** * Construct a program object from a list of devices and a per-device list of binaries. @@ -6543,12 +6837,12 @@ class Program : public detail::Wrapper * match the size of binaries and filled with values to specify if each binary * was successfully loaded. * Set to CL_SUCCESS if the binary was successfully loaded. - * Set to CL_INVALID_VALUE if the length is 0 or the binary pointer is NULL. + * Set to CL_INVALID_VALUE if the length is 0 or the binary pointer is nullptr. * Set to CL_INVALID_BINARY if the binary provided is not valid for the matching device. - * \param err if non-NULL will be set to CL_SUCCESS on successful operation or one of the following errors: + * \param err if non-nullptr will be set to CL_SUCCESS on successful operation or one of the following errors: * CL_INVALID_CONTEXT if context is not a valid context. * CL_INVALID_VALUE if the length of devices is zero; or if the length of binaries does not match the length of devices; - * or if any entry in binaries is NULL or has length 0. + * or if any entry in binaries is nullptr or has length 0. * CL_INVALID_DEVICE if OpenCL devices listed in devices are not in the list of devices associated with context. * CL_INVALID_BINARY if an invalid program binary was encountered for any device. binaryStatus will return specific status for each device. * CL_OUT_OF_HOST_MEMORY if there is a failure to allocate resources required by the OpenCL implementation on the host. @@ -6557,8 +6851,8 @@ class Program : public detail::Wrapper const Context& context, const vector& devices, const Binaries& binaries, - vector* binaryStatus = NULL, - cl_int* err = NULL) + vector* binaryStatus = nullptr, + cl_int* err = nullptr) { cl_int error; @@ -6568,13 +6862,12 @@ class Program : public detail::Wrapper if(binaries.size() != numDevices) { error = CL_INVALID_VALUE; detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } return; } - vector lengths(numDevices); vector images(numDevices); #if !defined(CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY) @@ -6588,7 +6881,7 @@ class Program : public detail::Wrapper lengths[i] = binaries[(int)i].second; } #endif // #if !defined(CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY) - + vector deviceIDs(numDevices); for( size_type deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) { deviceIDs[deviceIndex] = (devices[deviceIndex])(); @@ -6597,16 +6890,16 @@ class Program : public detail::Wrapper if(binaryStatus) { binaryStatus->resize(numDevices); } - + object_ = ::clCreateProgramWithBinary( context(), (cl_uint) devices.size(), deviceIDs.data(), - lengths.data(), images.data(), (binaryStatus != NULL && numDevices > 0) + lengths.data(), images.data(), (binaryStatus != nullptr && numDevices > 0) ? &binaryStatus->front() - : NULL, &error); + : nullptr, &error); detail::errHandler(error, __CREATE_PROGRAM_WITH_BINARY_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6621,7 +6914,7 @@ class Program : public detail::Wrapper const Context& context, const vector& devices, const string& kernelNames, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -6640,7 +6933,7 @@ class Program : public detail::Wrapper &error); detail::errHandler(error, __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -6664,43 +6957,24 @@ class Program : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - Program(const Program& program) : detail::Wrapper(program) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - Program& operator = (const Program &program) - { - detail::Wrapper::operator=(program); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - Program(Program&& program) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(program)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - Program& operator = (Program &&program) + cl_int build( + const vector& devices, + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { - detail::Wrapper::operator=(std::move(program)); - return *this; + return build(devices, options.c_str(), notifyFptr, data); } cl_int build( const vector& devices, - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL) const + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { size_type numDevices = devices.size(); vector deviceIDs(numDevices); - + for( size_type deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) { deviceIDs[deviceIndex] = (devices[deviceIndex])(); } @@ -6719,9 +6993,18 @@ class Program : public detail::Wrapper cl_int build( const Device& device, - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL) const + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + return build(device, options.c_str(), notifyFptr, data); + } + + cl_int build( + const Device& device, + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { cl_device_id deviceID = device(); @@ -6739,14 +7022,22 @@ class Program : public detail::Wrapper } cl_int build( - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL) const + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + return build(options.c_str(), notifyFptr, data); + } + + cl_int build( + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { cl_int buildError = ::clBuildProgram( object_, 0, - NULL, + nullptr, options, notifyFptr, data); @@ -6756,48 +7047,134 @@ class Program : public detail::Wrapper #if CL_HPP_TARGET_OPENCL_VERSION >= 120 cl_int compile( - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL) const + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + return compile(options.c_str(), notifyFptr, data); + } + + cl_int compile( + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { cl_int error = ::clCompileProgram( object_, 0, - NULL, + nullptr, options, 0, - NULL, - NULL, + nullptr, + nullptr, notifyFptr, data); return detail::buildErrHandler(error, __COMPILE_PROGRAM_ERR, getBuildInfo()); } -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 - template - cl_int getInfo(cl_program_info name, T* param) const + cl_int compile( + const string& options, + const vector& inputHeaders, + const vector& headerIncludeNames, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const { - return detail::errHandler( - detail::getInfo(&::clGetProgramInfo, object_, name, param), - __GET_PROGRAM_INFO_ERR); + return compile(options.c_str(), inputHeaders, headerIncludeNames, notifyFptr, data); } - template typename - detail::param_traits::param_type - getInfo(cl_int* err = NULL) const - { - typename detail::param_traits< - detail::cl_program_info, name>::param_type param; - cl_int result = getInfo(name, ¶m); - if (err != NULL) { - *err = result; + cl_int compile( + const char* options, + const vector& inputHeaders, + const vector& headerIncludeNames, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + static_assert(sizeof(cl::Program) == sizeof(cl_program), + "Size of cl::Program must be equal to size of cl_program"); + vector headerIncludeNamesCStr; + for(const string& name: headerIncludeNames) { + headerIncludeNamesCStr.push_back(name.c_str()); } - return param; + cl_int error = ::clCompileProgram( + object_, + 0, + nullptr, + options, + static_cast(inputHeaders.size()), + reinterpret_cast(inputHeaders.data()), + reinterpret_cast(headerIncludeNamesCStr.data()), + notifyFptr, + data); + return detail::buildErrHandler(error, __COMPILE_PROGRAM_ERR, getBuildInfo()); } - template - cl_int getBuildInfo( - const Device& device, cl_program_build_info name, T* param) const + cl_int compile( + const string& options, + const vector& deviceList, + const vector& inputHeaders = vector(), + const vector& headerIncludeNames = vector(), + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + return compile(options.c_str(), deviceList, inputHeaders, headerIncludeNames, notifyFptr, data); + } + + cl_int compile( + const char* options, + const vector& deviceList, + const vector& inputHeaders = vector(), + const vector& headerIncludeNames = vector(), + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr) const + { + static_assert(sizeof(cl::Program) == sizeof(cl_program), + "Size of cl::Program must be equal to size of cl_program"); + vector headerIncludeNamesCStr; + for(const string& name: headerIncludeNames) { + headerIncludeNamesCStr.push_back(name.c_str()); + } + vector deviceIDList; + for(const Device& device: deviceList) { + deviceIDList.push_back(device()); + } + cl_int error = ::clCompileProgram( + object_, + static_cast(deviceList.size()), + reinterpret_cast(deviceIDList.data()), + options, + static_cast(inputHeaders.size()), + reinterpret_cast(inputHeaders.data()), + reinterpret_cast(headerIncludeNamesCStr.data()), + notifyFptr, + data); + return detail::buildErrHandler(error, __COMPILE_PROGRAM_ERR, getBuildInfo()); + } +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 + + template + cl_int getInfo(cl_program_info name, T* param) const + { + return detail::errHandler( + detail::getInfo(&::clGetProgramInfo, object_, name, param), + __GET_PROGRAM_INFO_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_program_info, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != nullptr) { + *err = result; + } + return param; + } + + template + cl_int getBuildInfo( + const Device& device, cl_program_build_info name, T* param) const { return detail::errHandler( detail::getInfo( @@ -6807,12 +7184,12 @@ class Program : public detail::Wrapper template typename detail::param_traits::param_type - getBuildInfo(const Device& device, cl_int* err = NULL) const + getBuildInfo(const Device& device, cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_program_build_info, name>::param_type param; cl_int result = getBuildInfo(device, name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -6825,7 +7202,7 @@ class Program : public detail::Wrapper */ template vector::param_type>> - getBuildInfo(cl_int *err = NULL) const + getBuildInfo(cl_int *err = nullptr) const { cl_int result = CL_SUCCESS; @@ -6835,7 +7212,7 @@ class Program : public detail::Wrapper // If there was an initial error from getInfo return the error if (result != CL_SUCCESS) { - if (err != NULL) { + if (err != nullptr) { *err = result; } return devInfo; @@ -6853,7 +7230,7 @@ class Program : public detail::Wrapper break; } } - if (err != NULL) { + if (err != nullptr) { *err = result; } if (result != CL_SUCCESS) { @@ -6865,7 +7242,7 @@ class Program : public detail::Wrapper cl_int createKernels(vector* kernels) { cl_uint numKernels; - cl_int err = ::clCreateKernelsInProgram(object_, 0, NULL, &numKernels); + cl_int err = ::clCreateKernelsInProgram(object_, 0, nullptr, &numKernels); if (err != CL_SUCCESS) { return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR); } @@ -6873,7 +7250,7 @@ class Program : public detail::Wrapper vector value(numKernels); err = ::clCreateKernelsInProgram( - object_, numKernels, value.data(), NULL); + object_, numKernels, value.data(), nullptr); if (err != CL_SUCCESS) { return detail::errHandler(err, __CREATE_KERNELS_IN_PROGRAM_ERR); } @@ -6906,7 +7283,7 @@ class Program : public detail::Wrapper */ CL_API_PREFIX__VERSION_2_2_DEPRECATED cl_int setReleaseCallback( void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), - void * user_data = NULL) CL_API_SUFFIX__VERSION_2_2_DEPRECATED + void * user_data = nullptr) CL_API_SUFFIX__VERSION_2_2_DEPRECATED { return detail::errHandler( ::clSetProgramReleaseCallback( @@ -6953,15 +7330,14 @@ class Program : public detail::Wrapper #if CL_HPP_TARGET_OPENCL_VERSION >= 120 inline Program linkProgram( - Program input1, - Program input2, - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL, - cl_int* err = NULL) + const Program& input1, + const Program& input2, + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) { cl_int error_local = CL_SUCCESS; - cl_program programs[2] = { input1(), input2() }; Context ctx = input1.getInfo(&error_local); @@ -6972,7 +7348,7 @@ inline Program linkProgram( cl_program prog = ::clLinkProgram( ctx(), 0, - NULL, + nullptr, options, 2, programs, @@ -6981,7 +7357,7 @@ inline Program linkProgram( &error_local); detail::errHandler(error_local,__COMPILE_PROGRAM_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error_local; } @@ -6989,44 +7365,63 @@ inline Program linkProgram( } inline Program linkProgram( - vector inputPrograms, - const char* options = NULL, - void (CL_CALLBACK * notifyFptr)(cl_program, void *) = NULL, - void* data = NULL, - cl_int* err = NULL) + const Program& input1, + const Program& input2, + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) +{ + return linkProgram(input1, input2, options.c_str(), notifyFptr, data, err); +} + +inline Program linkProgram( + const vector& inputPrograms, + const char* options = nullptr, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) { cl_int error_local = CL_SUCCESS; + Context ctx; - vector programs(inputPrograms.size()); + static_assert(sizeof(cl::Program) == sizeof(cl_program), + "Size of cl::Program must be equal to size of cl_program"); - for (unsigned int i = 0; i < inputPrograms.size(); i++) { - programs[i] = inputPrograms[i](); - } - - Context ctx; if(inputPrograms.size() > 0) { ctx = inputPrograms[0].getInfo(&error_local); if(error_local!=CL_SUCCESS) { detail::errHandler(error_local, __LINK_PROGRAM_ERR); } } + cl_program prog = ::clLinkProgram( ctx(), 0, - NULL, + nullptr, options, - (cl_uint)inputPrograms.size(), - programs.data(), + static_cast(inputPrograms.size()), + reinterpret_cast(inputPrograms.data()), notifyFptr, data, &error_local); detail::errHandler(error_local,__COMPILE_PROGRAM_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error_local; } - return Program(prog, false); + return Program(prog); +} + +inline Program linkProgram( + const vector& inputPrograms, + const string& options, + void (CL_CALLBACK * notifyFptr)(cl_program, void *) = nullptr, + void* data = nullptr, + cl_int* err = nullptr) +{ + return linkProgram(inputPrograms, options.c_str(), notifyFptr, data, err); } #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 @@ -7064,7 +7459,7 @@ inline vector> cl::Program::getInfo(c vector> binariesVectors; cl_int result = getInfo(CL_PROGRAM_BINARIES, &binariesVectors); - if (err != NULL) { + if (err != nullptr) { *err = result; } return binariesVectors; @@ -7086,6 +7481,18 @@ inline cl_int cl::Program::setSpecializationConstant(cl_uint index, const bool & } #endif // CL_HPP_TARGET_OPENCL_VERSION >= 220 +inline Kernel::Kernel(const Program& program, const string& name, cl_int* err) +{ + cl_int error; + + object_ = ::clCreateKernel(program(), name.c_str(), &error); + detail::errHandler(error, __CREATE_KERNEL_ERR); + + if (err != nullptr) { + *err = error; + } +} + inline Kernel::Kernel(const Program& program, const char* name, cl_int* err) { cl_int error; @@ -7093,12 +7500,28 @@ inline Kernel::Kernel(const Program& program, const char* name, cl_int* err) object_ = ::clCreateKernel(program(), name, &error); detail::errHandler(error, __CREATE_KERNEL_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } - } +#ifdef cl_khr_external_memory +enum class ExternalMemoryType : cl_external_memory_handle_type_khr +{ + None = 0, +#ifdef cl_khr_external_memory_opaque_fd + OpaqueFd = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR, +#endif // cl_khr_external_memory_opaque_fd +#ifdef cl_khr_external_memory_win32 + OpaqueWin32 = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KHR, + OpaqueWin32Kmt = CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_WIN32_KMT_KHR, +#endif // cl_khr_external_memory_win32 +#ifdef cl_khr_external_memory_dma_buf + DmaBuf = CL_EXTERNAL_MEMORY_HANDLE_DMA_BUF_KHR, +#endif // cl_khr_external_memory_dma_buf +}; +#endif // cl_khr_external_memory + enum class QueueProperties : cl_command_queue_properties { None = 0, @@ -7167,6 +7590,24 @@ class CommandQueue : public detail::Wrapper default_ = c; } +#ifdef cl_khr_external_memory + static std::once_flag ext_memory_initialized_; + + static void initMemoryExtension(const cl::Device& device) + { + auto platform = device.getInfo()(); + + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueAcquireExternalMemObjectsKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueReleaseExternalMemObjectsKHR); + + if ((pfn_clEnqueueAcquireExternalMemObjectsKHR == nullptr) + && (pfn_clEnqueueReleaseExternalMemObjectsKHR == nullptr)) + { + detail::errHandler(CL_INVALID_VALUE, __ENQUEUE_ACQUIRE_EXTERNAL_MEMORY_ERR); + } + } +#endif // cl_khr_external_memory + public: #ifdef CL_HPP_UNIT_TEST_ENABLE /*! \brief Reset the default. @@ -7187,7 +7628,7 @@ class CommandQueue : public detail::Wrapper */ CommandQueue( cl_command_queue_properties properties, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -7195,7 +7636,7 @@ class CommandQueue : public detail::Wrapper detail::errHandler(error, __CREATE_CONTEXT_ERR); if (error != CL_SUCCESS) { - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7228,7 +7669,7 @@ class CommandQueue : public detail::Wrapper } detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7239,7 +7680,7 @@ class CommandQueue : public detail::Wrapper context(), device(), properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7253,7 +7694,7 @@ class CommandQueue : public detail::Wrapper */ CommandQueue( QueueProperties properties, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -7261,7 +7702,7 @@ class CommandQueue : public detail::Wrapper detail::errHandler(error, __CREATE_CONTEXT_ERR); if (error != CL_SUCCESS) { - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7290,7 +7731,7 @@ class CommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7301,7 +7742,7 @@ class CommandQueue : public detail::Wrapper context(), device(), static_cast(properties), &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7317,7 +7758,7 @@ class CommandQueue : public detail::Wrapper explicit CommandQueue( const Context& context, cl_command_queue_properties properties = 0, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; bool useWithProperties; @@ -7328,7 +7769,7 @@ class CommandQueue : public detail::Wrapper if (error != CL_SUCCESS) { - if (err != NULL) { + if (err != nullptr) { *err = error; } return; @@ -7359,7 +7800,7 @@ class CommandQueue : public detail::Wrapper } detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7370,7 +7811,7 @@ class CommandQueue : public detail::Wrapper context(), devices[0](), properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7384,7 +7825,7 @@ class CommandQueue : public detail::Wrapper explicit CommandQueue( const Context& context, QueueProperties properties, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; bool useWithProperties; @@ -7395,7 +7836,7 @@ class CommandQueue : public detail::Wrapper if (error != CL_SUCCESS) { - if (err != NULL) { + if (err != nullptr) { *err = error; } return; @@ -7421,7 +7862,7 @@ class CommandQueue : public detail::Wrapper context(), devices[0](), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7432,7 +7873,7 @@ class CommandQueue : public detail::Wrapper context(), devices[0](), static_cast(properties), &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7447,7 +7888,7 @@ class CommandQueue : public detail::Wrapper const Context& context, const Device& device, cl_command_queue_properties properties = 0, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; bool useWithProperties; @@ -7472,7 +7913,7 @@ class CommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7483,7 +7924,7 @@ class CommandQueue : public detail::Wrapper context(), device(), properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7498,7 +7939,7 @@ class CommandQueue : public detail::Wrapper const Context& context, const Device& device, QueueProperties properties, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; bool useWithProperties; @@ -7523,7 +7964,7 @@ class CommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -7534,14 +7975,14 @@ class CommandQueue : public detail::Wrapper context(), device(), static_cast(properties), &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } #endif // CL_HPP_MINIMUM_OPENCL_VERSION < 200 } - static CommandQueue getDefault(cl_int * err = NULL) + static CommandQueue getDefault(cl_int * err = nullptr) { std::call_once(default_initialized_, makeDefault); #if CL_HPP_TARGET_OPENCL_VERSION >= 200 @@ -7549,7 +7990,7 @@ class CommandQueue : public detail::Wrapper #else // CL_HPP_TARGET_OPENCL_VERSION >= 200 detail::errHandler(default_error_, __CREATE_COMMAND_QUEUE_ERR); #endif // CL_HPP_TARGET_OPENCL_VERSION >= 200 - if (err != NULL) { + if (err != nullptr) { *err = default_error_; } return default_; @@ -7587,34 +8028,6 @@ class CommandQueue : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - CommandQueue(const CommandQueue& queue) : detail::Wrapper(queue) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - CommandQueue& operator = (const CommandQueue &queue) - { - detail::Wrapper::operator=(queue); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - CommandQueue(CommandQueue&& queue) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(queue)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - CommandQueue& operator = (CommandQueue &&queue) - { - detail::Wrapper::operator=(std::move(queue)); - return *this; - } - template cl_int getInfo(cl_command_queue_info name, T* param) const { @@ -7626,12 +8039,12 @@ class CommandQueue : public detail::Wrapper template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_command_queue_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -7643,20 +8056,20 @@ class CommandQueue : public detail::Wrapper size_type offset, size_type size, void* ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueReadBuffer( object_, buffer(), blocking, offset, size, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_READ_BUFFER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -7668,20 +8081,20 @@ class CommandQueue : public detail::Wrapper size_type offset, size_type size, const void* ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueWriteBuffer( object_, buffer(), blocking, offset, size, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_WRITE_BUFFER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -7693,19 +8106,19 @@ class CommandQueue : public detail::Wrapper size_type src_offset, size_type dst_offset, size_type size, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueCopyBuffer( object_, src(), dst(), src_offset, dst_offset, size, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQEUE_COPY_BUFFER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -7722,8 +8135,8 @@ class CommandQueue : public detail::Wrapper size_type host_row_pitch, size_type host_slice_pitch, void *ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7739,17 +8152,46 @@ class CommandQueue : public detail::Wrapper host_row_pitch, host_slice_pitch, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_READ_BUFFER_RECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueReadBufferRect( + const Buffer& buffer, + cl_bool blocking, + const array& buffer_offset, + const array& host_offset, + const array& region, + size_type buffer_row_pitch, + size_type buffer_slice_pitch, + size_type host_row_pitch, + size_type host_slice_pitch, + void* ptr, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueReadBufferRect( + buffer, + blocking, + { buffer_offset[0], buffer_offset[1], 0 }, + { host_offset[0], host_offset[1], 0 }, + { region[0], region[1], 1 }, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); + } + cl_int enqueueWriteBufferRect( const Buffer& buffer, cl_bool blocking, @@ -7761,8 +8203,8 @@ class CommandQueue : public detail::Wrapper size_type host_row_pitch, size_type host_slice_pitch, const void *ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7778,17 +8220,46 @@ class CommandQueue : public detail::Wrapper host_row_pitch, host_slice_pitch, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_WRITE_BUFFER_RECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueWriteBufferRect( + const Buffer& buffer, + cl_bool blocking, + const array& buffer_offset, + const array& host_offset, + const array& region, + size_type buffer_row_pitch, + size_type buffer_slice_pitch, + size_type host_row_pitch, + size_type host_slice_pitch, + const void* ptr, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueWriteBufferRect( + buffer, + blocking, + { buffer_offset[0], buffer_offset[1], 0 }, + { host_offset[0], host_offset[1], 0 }, + { region[0], region[1], 1 }, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); + } + cl_int enqueueCopyBufferRect( const Buffer& src, const Buffer& dst, @@ -7799,8 +8270,8 @@ class CommandQueue : public detail::Wrapper size_type src_slice_pitch, size_type dst_row_pitch, size_type dst_slice_pitch, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7815,16 +8286,44 @@ class CommandQueue : public detail::Wrapper src_slice_pitch, dst_row_pitch, dst_slice_pitch, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQEUE_COPY_BUFFER_RECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + + cl_int enqueueCopyBufferRect( + const Buffer& src, + const Buffer& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + size_type src_row_pitch, + size_type src_slice_pitch, + size_type dst_row_pitch, + size_type dst_slice_pitch, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueCopyBufferRect( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + events, + event); + } + #endif // CL_HPP_TARGET_OPENCL_VERSION >= 110 #if CL_HPP_TARGET_OPENCL_VERSION >= 120 /** @@ -7844,8 +8343,8 @@ class CommandQueue : public detail::Wrapper PatternType pattern, size_type offset, size_type size, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7856,12 +8355,12 @@ class CommandQueue : public detail::Wrapper sizeof(PatternType), offset, size, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_FILL_BUFFER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -7876,8 +8375,8 @@ class CommandQueue : public detail::Wrapper size_type row_pitch, size_type slice_pitch, void* ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7890,17 +8389,40 @@ class CommandQueue : public detail::Wrapper row_pitch, slice_pitch, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_READ_IMAGE_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueReadImage( + const Image& image, + cl_bool blocking, + const array& origin, + const array& region, + size_type row_pitch, + size_type slice_pitch, + void* ptr, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueReadImage( + image, + blocking, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, + row_pitch, + slice_pitch, + ptr, + events, + event); + } + cl_int enqueueWriteImage( const Image& image, cl_bool blocking, @@ -7909,8 +8431,8 @@ class CommandQueue : public detail::Wrapper size_type row_pitch, size_type slice_pitch, const void* ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7923,25 +8445,48 @@ class CommandQueue : public detail::Wrapper row_pitch, slice_pitch, ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_WRITE_IMAGE_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueWriteImage( + const Image& image, + cl_bool blocking, + const array& origin, + const array& region, + size_type row_pitch, + size_type slice_pitch, + const void* ptr, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueWriteImage( + image, + blocking, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, + row_pitch, + slice_pitch, + ptr, + events, + event); + } + cl_int enqueueCopyImage( const Image& src, const Image& dst, const array& src_origin, const array& dst_origin, const array& region, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -7952,118 +8497,102 @@ class CommandQueue : public detail::Wrapper src_origin.data(), dst_origin.data(), region.data(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_IMAGE_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } -#if CL_HPP_TARGET_OPENCL_VERSION >= 120 - /** - * Enqueue a command to fill an image object with a specified color. - * \param fillColor is the color to use to fill the image. - * This is a four component RGBA floating-point color value if - * the image channel data type is not an unnormalized signed or - * unsigned data type. - */ - cl_int enqueueFillImage( - const Image& image, - cl_float4 fillColor, - const array& origin, - const array& region, - const vector* events = NULL, - Event* event = NULL) const - { - cl_event tmp; - cl_int err = detail::errHandler( - ::clEnqueueFillImage( - object_, - image(), - static_cast(&fillColor), - origin.data(), - region.data(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_FILL_IMAGE_ERR); - - if (event != NULL && err == CL_SUCCESS) - *event = tmp; - - return err; + cl_int enqueueCopyImage( + const Image& src, + const Image& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueCopyImage( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + events, + event); } +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 /** * Enqueue a command to fill an image object with a specified color. * \param fillColor is the color to use to fill the image. - * This is a four component RGBA signed integer color value if - * the image channel data type is an unnormalized signed integer - * type. + * This is a four component RGBA floating-point, signed integer + * or unsigned integer color value if the image channel data + * type is an unnormalized signed integer type. */ - cl_int enqueueFillImage( - const Image& image, - cl_int4 fillColor, - const array& origin, - const array& region, - const vector* events = NULL, - Event* event = NULL) const + template + typename std::enable_if::value || + std::is_same::value || + std::is_same::value, + cl_int>::type + enqueueFillImage( + const Image& image, + T fillColor, + const array& origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueFillImage( - object_, + object_, image(), - static_cast(&fillColor), + static_cast(&fillColor), origin.data(), region.data(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_FILL_IMAGE_ERR); + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : NULL, + (event != NULL) ? &tmp : nullptr), + __ENQUEUE_FILL_IMAGE_ERR); - if (event != NULL && err == CL_SUCCESS) - *event = tmp; + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } - /** + /** * Enqueue a command to fill an image object with a specified color. * \param fillColor is the color to use to fill the image. - * This is a four component RGBA unsigned integer color value if - * the image channel data type is an unnormalized unsigned integer - * type. + * This is a four component RGBA floating-point, signed integer + * or unsigned integer color value if the image channel data + * type is an unnormalized signed integer type. */ - cl_int enqueueFillImage( + template + typename std::enable_if::value || + std::is_same::value || + std::is_same::value, cl_int>::type + enqueueFillImage( const Image& image, - cl_uint4 fillColor, - const array& origin, - const array& region, - const vector* events = NULL, - Event* event = NULL) const - { - cl_event tmp; - cl_int err = detail::errHandler( - ::clEnqueueFillImage( - object_, - image(), - static_cast(&fillColor), - origin.data(), - region.data(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_FILL_IMAGE_ERR); - - if (event != NULL && err == CL_SUCCESS) - *event = tmp; - - return err; + T fillColor, + const array& origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueFillImage( + image, + fillColor, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, + events, + event + ); } #endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 @@ -8073,8 +8602,8 @@ class CommandQueue : public detail::Wrapper const array& src_origin, const array& region, size_type dst_offset, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -8085,25 +8614,44 @@ class CommandQueue : public detail::Wrapper src_origin.data(), region.data(), dst_offset, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueCopyImageToBuffer( + const Image& src, + const Buffer& dst, + const array& src_origin, + const array& region, + size_type dst_offset, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueCopyImageToBuffer( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { region[0], region[1], 1 }, + dst_offset, + events, + event); + } + cl_int enqueueCopyBufferToImage( const Buffer& src, const Image& dst, size_type src_offset, const array& dst_origin, const array& region, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( @@ -8114,178 +8662,371 @@ class CommandQueue : public detail::Wrapper src_offset, dst_origin.data(), region.data(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } + cl_int enqueueCopyBufferToImage( + const Buffer& src, + const Image& dst, + size_type src_offset, + const array& dst_origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) const + { + return enqueueCopyBufferToImage( + src, + dst, + src_offset, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + events, + event); + } + void* enqueueMapBuffer( const Buffer& buffer, cl_bool blocking, cl_map_flags flags, size_type offset, size_type size, - const vector* events = NULL, - Event* event = NULL, - cl_int* err = NULL) const + const vector* events = nullptr, + Event* event = nullptr, + cl_int* err = nullptr) const { cl_event tmp; cl_int error; void * result = ::clEnqueueMapBuffer( object_, buffer(), blocking, flags, offset, size, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr, &error); detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } - if (event != NULL && error == CL_SUCCESS) + if (event != nullptr && error == CL_SUCCESS) *event = tmp; return result; } void* enqueueMapImage( - const Image& buffer, + const Image& image, cl_bool blocking, cl_map_flags flags, const array& origin, const array& region, size_type * row_pitch, size_type * slice_pitch, - const vector* events = NULL, - Event* event = NULL, - cl_int* err = NULL) const + const vector* events = nullptr, + Event* event = nullptr, + cl_int* err = nullptr) const { cl_event tmp; cl_int error; void * result = ::clEnqueueMapImage( - object_, buffer(), blocking, flags, + object_, image(), blocking, flags, origin.data(), region.data(), row_pitch, slice_pitch, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr, &error); detail::errHandler(error, __ENQUEUE_MAP_IMAGE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } - if (event != NULL && error == CL_SUCCESS) + if (event != nullptr && error == CL_SUCCESS) *event = tmp; return result; } + void* enqueueMapImage( + const Image& image, + cl_bool blocking, + cl_map_flags flags, + const array& origin, + const array& region, + size_type* row_pitch, + size_type* slice_pitch, + const vector* events = nullptr, + Event* event = nullptr, + cl_int* err = nullptr) const + { + return enqueueMapImage(image, blocking, flags, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, row_pitch, + slice_pitch, events, event, err); + } + #if CL_HPP_TARGET_OPENCL_VERSION >= 200 + /** - * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. - * This variant takes a raw SVM pointer. - */ + * Enqueues a command that copies a region of memory from the source pointer to the destination pointer. + * This function is specifically for transferring data between the host and a coarse-grained SVM buffer. + */ template - cl_int enqueueMapSVM( - T* ptr, - cl_bool blocking, - cl_map_flags flags, - size_type size, - const vector* events = NULL, - Event* event = NULL) const - { + cl_int enqueueMemcpySVM( + T *dst_ptr, + const T *src_ptr, + cl_bool blocking, + size_type size, + const vector *events = nullptr, + Event *event = nullptr) const { cl_event tmp; - cl_int err = detail::errHandler(::clEnqueueSVMMap( - object_, blocking, flags, static_cast(ptr), size, - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_MAP_BUFFER_ERR); + cl_int err = detail::errHandler(::clEnqueueSVMMemcpy( + object_, blocking, static_cast(dst_ptr), static_cast(src_ptr), size, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } - /** - * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. - * This variant takes a cl::pointer instance. - */ + *Enqueues a command that will copy data from one coarse-grained SVM buffer to another. + *This function takes two cl::pointer instances representing the destination and source buffers. + */ template - cl_int enqueueMapSVM( - cl::pointer &ptr, - cl_bool blocking, - cl_map_flags flags, - size_type size, - const vector* events = NULL, - Event* event = NULL) const - { + cl_int enqueueMemcpySVM( + cl::pointer &dst_ptr, + const cl::pointer &src_ptr, + cl_bool blocking, + size_type size, + const vector *events = nullptr, + Event *event = nullptr) const { cl_event tmp; - cl_int err = detail::errHandler(::clEnqueueSVMMap( - object_, blocking, flags, static_cast(ptr.get()), size, - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_MAP_BUFFER_ERR); + cl_int err = detail::errHandler(::clEnqueueSVMMemcpy( + object_, blocking, static_cast(dst_ptr.get()), static_cast(src_ptr.get()), + size, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } /** - * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. - * This variant takes a cl::vector instance. - */ + * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. + * This variant takes a cl::vector instance. + */ template - cl_int enqueueMapSVM( - cl::vector &container, - cl_bool blocking, - cl_map_flags flags, - const vector* events = NULL, - Event* event = NULL) const - { + cl_int enqueueMemcpySVM( + cl::vector &dst_container, + const cl::vector &src_container, + cl_bool blocking, + const vector *events = nullptr, + Event *event = nullptr) const { cl_event tmp; - cl_int err = detail::errHandler(::clEnqueueSVMMap( - object_, blocking, flags, static_cast(container.data()), container.size()*sizeof(T), - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_MAP_BUFFER_ERR); - - if (event != NULL && err == CL_SUCCESS) + if(src_container.size() != dst_container.size()){ + return detail::errHandler(CL_INVALID_VALUE,__ENQUEUE_COPY_SVM_ERR); + } + cl_int err = detail::errHandler(::clEnqueueSVMMemcpy( + object_, blocking, static_cast(dst_container.data()), + static_cast(src_container.data()), + dst_container.size() * sizeof(T), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != NULL) ? &tmp : nullptr), __ENQUEUE_COPY_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } -#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 + + /** + * Enqueues a command to fill a SVM buffer with a pattern. + * + */ + template + cl_int enqueueMemFillSVM( + T *ptr, + PatternType pattern, + size_type size, + const vector *events = nullptr, + Event *event = nullptr) const { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMemFill( + object_, static_cast(ptr), static_cast(&pattern), + sizeof(PatternType), size, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_FILL_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + /** + * Enqueues a command that fills a region of a coarse-grained SVM buffer with a specified pattern. + * This variant takes a cl::pointer instance. + */ + template + cl_int enqueueMemFillSVM( + cl::pointer &ptr, + PatternType pattern, + size_type size, + const vector *events = nullptr, + Event *event = nullptr) const { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMemFill( + object_, static_cast(ptr.get()), static_cast(&pattern), + sizeof(PatternType), size, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_FILL_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + /** + * Enqueues a command that will allow the host to fill a region of a coarse-grained SVM buffer with a specified pattern. + * This variant takes a cl::vector instance. + */ + template + cl_int enqueueMemFillSVM( + cl::vector &container, + PatternType pattern, + const vector *events = nullptr, + Event* event = nullptr) const + { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMemFill( + object_, static_cast(container.data()), static_cast(&pattern), + sizeof(PatternType), container.size() * sizeof(T), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event *) &events->front() : nullptr, + (event != nullptr) ? &tmp : NULL), __ENQUEUE_FILL_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + /** + * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. + * This variant takes a raw SVM pointer. + */ + template + cl_int enqueueMapSVM( + T* ptr, + cl_bool blocking, + cl_map_flags flags, + size_type size, + const vector* events = nullptr, + Event* event = nullptr) const + { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMap( + object_, blocking, flags, static_cast(ptr), size, + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_MAP_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + + /** + * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. + * This variant takes a cl::pointer instance. + */ + template + cl_int enqueueMapSVM( + cl::pointer &ptr, + cl_bool blocking, + cl_map_flags flags, + size_type size, + const vector* events = nullptr, + Event* event = nullptr) const + { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMap( + object_, blocking, flags, static_cast(ptr.get()), size, + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_MAP_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + /** + * Enqueues a command that will allow the host to update a region of a coarse-grained SVM buffer. + * This variant takes a cl::vector instance. + */ + template + cl_int enqueueMapSVM( + cl::vector &container, + cl_bool blocking, + cl_map_flags flags, + const vector* events = nullptr, + Event* event = nullptr) const + { + cl_event tmp; + cl_int err = detail::errHandler(::clEnqueueSVMMap( + object_, blocking, flags, static_cast(container.data()), container.size()*sizeof(T), + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_MAP_SVM_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } +#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 cl_int enqueueUnmapMemObject( const Memory& memory, void* mapped_ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueUnmapMemObject( object_, memory(), mapped_ptr, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_UNMAP_MEM_OBJECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8300,19 +9041,19 @@ class CommandQueue : public detail::Wrapper template cl_int enqueueUnmapSVM( T* ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueSVMUnmap( object_, static_cast(ptr), - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_UNMAP_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8325,19 +9066,19 @@ class CommandQueue : public detail::Wrapper template cl_int enqueueUnmapSVM( cl::pointer &ptr, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueSVMUnmap( object_, static_cast(ptr.get()), - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_UNMAP_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8350,19 +9091,19 @@ class CommandQueue : public detail::Wrapper template cl_int enqueueUnmapSVM( cl::vector &container, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueSVMUnmap( object_, static_cast(container.data()), - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), + __ENQUEUE_UNMAP_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8382,19 +9123,19 @@ class CommandQueue : public detail::Wrapper * have completed. */ cl_int enqueueMarkerWithWaitList( - const vector *events = 0, - Event *event = 0) const + const vector *events = nullptr, + Event *event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueMarkerWithWaitList( object_, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_MARKER_WAIT_LIST_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8412,19 +9153,19 @@ class CommandQueue : public detail::Wrapper * before this command to command_queue, have completed. */ cl_int enqueueBarrierWithWaitList( - const vector *events = 0, - Event *event = 0) const + const vector *events = nullptr, + Event *event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueBarrierWithWaitList( object_, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_BARRIER_WAIT_LIST_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8437,8 +9178,8 @@ class CommandQueue : public detail::Wrapper cl_int enqueueMigrateMemObjects( const vector &memObjects, cl_mem_migration_flags flags, - const vector* events = NULL, - Event* event = NULL + const vector* events = nullptr, + Event* event = nullptr ) const { cl_event tmp; @@ -8455,12 +9196,12 @@ class CommandQueue : public detail::Wrapper (cl_uint)memObjects.size(), localMemObjects.data(), flags, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_UNMAP_MEM_OBJECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8479,8 +9220,8 @@ class CommandQueue : public detail::Wrapper const cl::vector &svmRawPointers, const cl::vector &sizes, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler(::clEnqueueSVMMigrateMem( @@ -8488,12 +9229,12 @@ class CommandQueue : public detail::Wrapper svmRawPointers.size(), static_cast(svmRawPointers.data()), sizes.data(), // array of sizes not passed flags, - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_MIGRATE_SVM_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8507,8 +9248,8 @@ class CommandQueue : public detail::Wrapper cl_int enqueueMigrateSVM( const cl::vector &svmRawPointers, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { return enqueueMigrateSVM(svmRawPointers, cl::vector(svmRawPointers.size()), flags, events, event); } @@ -8524,8 +9265,8 @@ class CommandQueue : public detail::Wrapper const cl::vector> &svmPointers, const cl::vector &sizes, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl::vector svmRawPointers; svmRawPointers.reserve(svmPointers.size()); @@ -8545,8 +9286,8 @@ class CommandQueue : public detail::Wrapper cl_int enqueueMigrateSVM( const cl::vector> &svmPointers, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { return enqueueMigrateSVM(svmPointers, cl::vector(svmPointers.size()), flags, events, event); } @@ -8561,8 +9302,8 @@ class CommandQueue : public detail::Wrapper const cl::vector> &svmContainers, const cl::vector &sizes, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl::vector svmRawPointers; svmRawPointers.reserve(svmContainers.size()); @@ -8581,8 +9322,8 @@ class CommandQueue : public detail::Wrapper cl_int enqueueMigrateSVM( const cl::vector> &svmContainers, cl_mem_migration_flags flags = 0, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { return enqueueMigrateSVM(svmContainers, cl::vector(svmContainers.size()), flags, events, event); } @@ -8594,22 +9335,22 @@ class CommandQueue : public detail::Wrapper const NDRange& offset, const NDRange& global, const NDRange& local = NullRange, - const vector* events = NULL, - Event* event = NULL) const + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueNDRangeKernel( object_, kernel(), (cl_uint) global.dimensions(), - offset.dimensions() != 0 ? (const size_type*) offset : NULL, + offset.dimensions() != 0 ? (const size_type*) offset : nullptr, (const size_type*) global, - local.dimensions() != 0 ? (const size_type*) local : NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + local.dimensions() != 0 ? (const size_type*) local : nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_NDRANGE_KERNEL_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8618,19 +9359,19 @@ class CommandQueue : public detail::Wrapper #if defined(CL_USE_DEPRECATED_OPENCL_1_2_APIS) CL_API_PREFIX__VERSION_1_2_DEPRECATED cl_int enqueueTask( const Kernel& kernel, - const vector* events = NULL, - Event* event = NULL) const CL_API_SUFFIX__VERSION_1_2_DEPRECATED + const vector* events = nullptr, + Event* event = nullptr) const CL_API_SUFFIX__VERSION_1_2_DEPRECATED { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueTask( object_, kernel(), - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_TASK_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8640,33 +9381,24 @@ class CommandQueue : public detail::Wrapper cl_int enqueueNativeKernel( void (CL_CALLBACK *userFptr)(void *), std::pair args, - const vector* mem_objects = NULL, - const vector* mem_locs = NULL, - const vector* events = NULL, - Event* event = NULL) const + const vector* mem_objects = nullptr, + const vector* mem_locs = nullptr, + const vector* events = nullptr, + Event* event = nullptr) const { - size_type elements = 0; - if (mem_objects != NULL) { - elements = mem_objects->size(); - } - vector mems(elements); - for (unsigned int i = 0; i < elements; i++) { - mems[i] = ((*mem_objects)[i])(); - } - cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueNativeKernel( object_, userFptr, args.first, args.second, - (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, - mems.data(), - (mem_locs != NULL && mem_locs->size() > 0) ? (const void **) &mem_locs->front() : NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0, + (mem_objects->size() > 0 ) ? reinterpret_cast(mem_objects->data()) : nullptr, + (mem_locs != nullptr && mem_locs->size() > 0) ? (const void **) &mem_locs->front() : nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_NATIVE_KERNEL); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8677,16 +9409,16 @@ class CommandQueue : public detail::Wrapper */ #if defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) CL_API_PREFIX__VERSION_1_1_DEPRECATED - cl_int enqueueMarker(Event* event = NULL) const CL_API_SUFFIX__VERSION_1_1_DEPRECATED + cl_int enqueueMarker(Event* event = nullptr) const CL_API_SUFFIX__VERSION_1_1_DEPRECATED { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueMarker( object_, - (event != NULL) ? &tmp : NULL), + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_MARKER_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8699,50 +9431,50 @@ class CommandQueue : public detail::Wrapper ::clEnqueueWaitForEvents( object_, (cl_uint) events.size(), - events.size() > 0 ? (const cl_event*) &events.front() : NULL), + events.size() > 0 ? (const cl_event*) &events.front() : nullptr), __ENQUEUE_WAIT_FOR_EVENTS_ERR); } #endif // defined(CL_USE_DEPRECATED_OPENCL_1_1_APIS) cl_int enqueueAcquireGLObjects( - const vector* mem_objects = NULL, - const vector* events = NULL, - Event* event = NULL) const + const vector* mem_objects = nullptr, + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueAcquireGLObjects( object_, - (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, - (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_ACQUIRE_GL_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } cl_int enqueueReleaseGLObjects( - const vector* mem_objects = NULL, - const vector* events = NULL, - Event* event = NULL) const + const vector* mem_objects = nullptr, + const vector* events = nullptr, + Event* event = nullptr) const { cl_event tmp; cl_int err = detail::errHandler( ::clEnqueueReleaseGLObjects( object_, - (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, - (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_RELEASE_GL_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8759,18 +9491,18 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)( const cl_event* event_wait_list, cl_event* event); cl_int enqueueAcquireD3D10Objects( - const vector* mem_objects = NULL, - const vector* events = NULL, - Event* event = NULL) const + const vector* mem_objects = nullptr, + const vector* events = nullptr, + Event* event = nullptr) const { - static PFN_clEnqueueAcquireD3D10ObjectsKHR pfn_clEnqueueAcquireD3D10ObjectsKHR = NULL; + static PFN_clEnqueueAcquireD3D10ObjectsKHR pfn_clEnqueueAcquireD3D10ObjectsKHR = nullptr; #if CL_HPP_TARGET_OPENCL_VERSION >= 120 cl_context context = getInfo(); cl::Device device(getInfo()); cl_platform_id platform = device.getInfo(); CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueAcquireD3D10ObjectsKHR); #endif -#if CL_HPP_TARGET_OPENCL_VERSION >= 110 +#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 CL_HPP_INIT_CL_EXT_FCN_PTR_(clEnqueueAcquireD3D10ObjectsKHR); #endif @@ -8778,47 +9510,47 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)( cl_int err = detail::errHandler( pfn_clEnqueueAcquireD3D10ObjectsKHR( object_, - (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, - (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_ACQUIRE_GL_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; } cl_int enqueueReleaseD3D10Objects( - const vector* mem_objects = NULL, - const vector* events = NULL, - Event* event = NULL) const + const vector* mem_objects = nullptr, + const vector* events = nullptr, + Event* event = nullptr) const { - static PFN_clEnqueueReleaseD3D10ObjectsKHR pfn_clEnqueueReleaseD3D10ObjectsKHR = NULL; + static PFN_clEnqueueReleaseD3D10ObjectsKHR pfn_clEnqueueReleaseD3D10ObjectsKHR = nullptr; #if CL_HPP_TARGET_OPENCL_VERSION >= 120 cl_context context = getInfo(); cl::Device device(getInfo()); cl_platform_id platform = device.getInfo(); CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueReleaseD3D10ObjectsKHR); -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 120 -#if CL_HPP_TARGET_OPENCL_VERSION >= 110 +#endif +#if CL_HPP_MINIMUM_OPENCL_VERSION < 120 CL_HPP_INIT_CL_EXT_FCN_PTR_(clEnqueueReleaseD3D10ObjectsKHR); -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 110 +#endif cl_event tmp; cl_int err = detail::errHandler( pfn_clEnqueueReleaseD3D10ObjectsKHR( object_, - (mem_objects != NULL) ? (cl_uint) mem_objects->size() : 0, - (mem_objects != NULL && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): NULL, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (mem_objects != nullptr) ? (cl_uint) mem_objects->size() : 0, + (mem_objects != nullptr && mem_objects->size() > 0) ? (const cl_mem *) &mem_objects->front(): nullptr, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_RELEASE_GL_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -8847,8 +9579,86 @@ typedef CL_API_ENTRY cl_int (CL_API_CALL *PFN_clEnqueueReleaseD3D10ObjectsKHR)( { return detail::errHandler(::clFinish(object_), __FINISH_ERR); } + +#ifdef cl_khr_external_memory + cl_int enqueueAcquireExternalMemObjects( + const vector& mem_objects, + const vector* events_wait = nullptr, + Event *event = nullptr) + { + cl_int err = CL_INVALID_OPERATION; + cl_event tmp; + + std::call_once(ext_memory_initialized_, initMemoryExtension, this->getInfo()); + + if (pfn_clEnqueueAcquireExternalMemObjectsKHR) + { + err = pfn_clEnqueueAcquireExternalMemObjectsKHR( + object_, + static_cast(mem_objects.size()), + (mem_objects.size() > 0) ? reinterpret_cast(mem_objects.data()) : nullptr, + (events_wait != nullptr) ? static_cast(events_wait->size()) : 0, + (events_wait != nullptr && events_wait->size() > 0) ? reinterpret_cast(events_wait->data()) : nullptr, + &tmp); + } + + detail::errHandler(err, __ENQUEUE_ACQUIRE_EXTERNAL_MEMORY_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } + + cl_int enqueueReleaseExternalMemObjects( + const vector& mem_objects, + const vector* events_wait = nullptr, + Event *event = nullptr) + { + cl_int err = CL_INVALID_OPERATION; + cl_event tmp; + + std::call_once(ext_memory_initialized_, initMemoryExtension, this->getInfo()); + + if (pfn_clEnqueueReleaseExternalMemObjectsKHR) + { + err = pfn_clEnqueueReleaseExternalMemObjectsKHR( + object_, + static_cast(mem_objects.size()), + (mem_objects.size() > 0) ? reinterpret_cast(mem_objects.data()) : nullptr, + (events_wait != nullptr) ? static_cast(events_wait->size()) : 0, + (events_wait != nullptr && events_wait->size() > 0) ? reinterpret_cast(events_wait->data()) : nullptr, + &tmp); + } + + detail::errHandler(err, __ENQUEUE_RELEASE_EXTERNAL_MEMORY_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; + } +#endif // cl_khr_external_memory && CL_HPP_TARGET_OPENCL_VERSION >= 300 + +#ifdef cl_khr_semaphore + cl_int enqueueWaitSemaphores( + const vector &sema_objects, + const vector &sema_payloads = {}, + const vector* events_wait_list = nullptr, + Event *event = nullptr) const; + + cl_int enqueueSignalSemaphores( + const vector &sema_objects, + const vector& sema_payloads = {}, + const vector* events_wait_list = nullptr, + Event* event = nullptr); +#endif // cl_khr_semaphore }; // CommandQueue +#ifdef cl_khr_external_memory +CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag CommandQueue::ext_memory_initialized_; +#endif + CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag CommandQueue::default_initialized_; CL_HPP_DEFINE_STATIC_MEMBER_ CommandQueue CommandQueue::default_; CL_HPP_DEFINE_STATIC_MEMBER_ cl_int CommandQueue::default_error_ = CL_SUCCESS; @@ -8881,7 +9691,7 @@ class DeviceCommandQueue : public detail::Wrapper /*! * Default construct device command queue on default context and device */ - DeviceCommandQueue(DeviceQueueProperties properties, cl_int* err = NULL) + DeviceCommandQueue(DeviceQueueProperties properties, cl_int* err = nullptr) { cl_int error; cl::Context context = cl::Context::getDefault(); @@ -8896,7 +9706,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -8908,7 +9718,7 @@ class DeviceCommandQueue : public detail::Wrapper const Context& context, const Device& device, DeviceQueueProperties properties = DeviceQueueProperties::None, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -8920,7 +9730,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -8933,7 +9743,7 @@ class DeviceCommandQueue : public detail::Wrapper const Device& device, cl_uint queueSize, DeviceQueueProperties properties = DeviceQueueProperties::None, - cl_int* err = NULL) + cl_int* err = nullptr) { cl_int error; @@ -8947,7 +9757,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -8967,34 +9777,6 @@ class DeviceCommandQueue : public detail::Wrapper return *this; } - /*! \brief Copy constructor to forward copy to the superclass correctly. - * Required for MSVC. - */ - DeviceCommandQueue(const DeviceCommandQueue& queue) : detail::Wrapper(queue) {} - - /*! \brief Copy assignment to forward copy to the superclass correctly. - * Required for MSVC. - */ - DeviceCommandQueue& operator = (const DeviceCommandQueue &queue) - { - detail::Wrapper::operator=(queue); - return *this; - } - - /*! \brief Move constructor to forward move to the superclass correctly. - * Required for MSVC. - */ - DeviceCommandQueue(DeviceCommandQueue&& queue) CL_HPP_NOEXCEPT_ : detail::Wrapper(std::move(queue)) {} - - /*! \brief Move assignment to forward move to the superclass correctly. - * Required for MSVC. - */ - DeviceCommandQueue& operator = (DeviceCommandQueue &&queue) - { - detail::Wrapper::operator=(std::move(queue)); - return *this; - } - template cl_int getInfo(cl_command_queue_info name, T* param) const { @@ -9006,12 +9788,12 @@ class DeviceCommandQueue : public detail::Wrapper template typename detail::param_traits::param_type - getInfo(cl_int* err = NULL) const + getInfo(cl_int* err = nullptr) const { typename detail::param_traits< detail::cl_command_queue_info, name>::param_type param; cl_int result = getInfo(name, ¶m); - if (err != NULL) { + if (err != nullptr) { *err = result; } return param; @@ -9040,7 +9822,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error)); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } @@ -9068,7 +9850,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error)); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } @@ -9097,7 +9879,7 @@ class DeviceCommandQueue : public detail::Wrapper context(), device(), queue_properties, &error)); detail::errHandler(error, __CREATE_COMMAND_QUEUE_WITH_PROPERTIES_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } @@ -9119,7 +9901,7 @@ class DeviceCommandQueue : public detail::Wrapper error = clSetDefaultDeviceCommandQueue(context.get(), device.get(), default_queue.get()); detail::errHandler(error, __SET_DEFAULT_DEVICE_COMMAND_QUEUE_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } return default_queue; @@ -9128,7 +9910,7 @@ class DeviceCommandQueue : public detail::Wrapper /*! * Return the current default command queue for the specified command queue */ - static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_int * err = NULL) + static DeviceCommandQueue getDefault(const CommandQueue &queue, cl_int * err = nullptr) { return queue.getInfo(err); } @@ -9182,20 +9964,20 @@ Buffer::Buffer( } detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } if( !useHostPtr ) { CommandQueue queue(context, 0, &error); detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } error = cl::copy(queue, startIterator, endIterator, *this); detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -9236,14 +10018,14 @@ Buffer::Buffer( } detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } if (!useHostPtr) { error = cl::copy(queue, startIterator, endIterator, *this); detail::errHandler(error, __CREATE_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } } @@ -9255,8 +10037,8 @@ inline cl_int enqueueReadBuffer( size_type offset, size_type size, void* ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9274,8 +10056,8 @@ inline cl_int enqueueWriteBuffer( size_type offset, size_type size, const void* ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9293,26 +10075,26 @@ inline void* enqueueMapBuffer( cl_map_flags flags, size_type offset, size_type size, - const vector* events = NULL, - Event* event = NULL, - cl_int* err = NULL) + const vector* events = nullptr, + Event* event = nullptr, + cl_int* err = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } void * result = ::clEnqueueMapBuffer( queue(), buffer(), blocking, flags, offset, size, - (events != NULL) ? (cl_uint) events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*) &events->front() : NULL, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, (cl_event*) event, &error); detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); - if (err != NULL) { + if (err != nullptr) { *err = error; } return result; @@ -9337,7 +10119,7 @@ inline cl_int enqueueMapSVM( cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); if (error != CL_SUCCESS) { - return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); + return detail::errHandler(error, __ENQUEUE_MAP_SVM_ERR); } return queue.enqueueMapSVM( @@ -9355,8 +10137,8 @@ inline cl_int enqueueMapSVM( cl_bool blocking, cl_map_flags flags, size_type size, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9378,13 +10160,13 @@ inline cl_int enqueueMapSVM( cl::vector &container, cl_bool blocking, cl_map_flags flags, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); if (error != CL_SUCCESS) { - return detail::errHandler(error, __ENQUEUE_MAP_BUFFER_ERR); + return detail::errHandler(error, __ENQUEUE_MAP_SVM_ERR); } return queue.enqueueMapSVM( @@ -9396,8 +10178,8 @@ inline cl_int enqueueMapSVM( inline cl_int enqueueUnmapMemObject( const Memory& memory, void* mapped_ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9410,12 +10192,12 @@ inline cl_int enqueueUnmapMemObject( cl_int err = detail::errHandler( ::clEnqueueUnmapMemObject( queue(), memory(), mapped_ptr, - (events != NULL) ? (cl_uint)events->size() : 0, - (events != NULL && events->size() > 0) ? (cl_event*)&events->front() : NULL, - (event != NULL) ? &tmp : NULL), + (events != nullptr) ? (cl_uint)events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*)&events->front() : nullptr, + (event != nullptr) ? &tmp : nullptr), __ENQUEUE_UNMAP_MEM_OBJECT_ERR); - if (event != NULL && err == CL_SUCCESS) + if (event != nullptr && err == CL_SUCCESS) *event = tmp; return err; @@ -9430,17 +10212,17 @@ inline cl_int enqueueUnmapMemObject( template inline cl_int enqueueUnmapSVM( T* ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); if (error != CL_SUCCESS) { - return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + return detail::errHandler(error, __ENQUEUE_UNMAP_SVM_ERR); } return detail::errHandler(queue.enqueueUnmapSVM(ptr, events, event), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + __ENQUEUE_UNMAP_SVM_ERR); } @@ -9452,17 +10234,17 @@ inline cl_int enqueueUnmapSVM( template inline cl_int enqueueUnmapSVM( cl::pointer &ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); if (error != CL_SUCCESS) { - return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + return detail::errHandler(error, __ENQUEUE_UNMAP_SVM_ERR); } return detail::errHandler(queue.enqueueUnmapSVM(ptr, events, event), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + __ENQUEUE_UNMAP_SVM_ERR); } /** @@ -9473,17 +10255,17 @@ inline cl_int enqueueUnmapSVM( template inline cl_int enqueueUnmapSVM( cl::vector &container, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); if (error != CL_SUCCESS) { - return detail::errHandler(error, __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + return detail::errHandler(error, __ENQUEUE_UNMAP_SVM_ERR); } return detail::errHandler(queue.enqueueUnmapSVM(container, events, event), - __ENQUEUE_UNMAP_MEM_OBJECT_ERR); + __ENQUEUE_UNMAP_SVM_ERR); } #endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 @@ -9494,8 +10276,8 @@ inline cl_int enqueueCopyBuffer( size_type src_offset, size_type dst_offset, size_type size, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9559,15 +10341,15 @@ inline cl_int copy( const CommandQueue &queue, IteratorType startIterator, Itera if( error != CL_SUCCESS ) { return error; } -#if defined(_MSC_VER) +#if defined(_MSC_VER) && _MSC_VER < 1920 std::copy( - startIterator, - endIterator, + startIterator, + endIterator, stdext::checked_array_iterator( pointer, length)); #else std::copy(startIterator, endIterator, pointer); -#endif +#endif // defined(_MSC_VER) && _MSC_VER < 1920 Event endEvent; error = queue.enqueueUnmapMemObject(buffer, pointer, 0, &endEvent); // if exceptions enabled, enqueueUnmapMemObject will throw @@ -9643,8 +10425,8 @@ inline cl_int enqueueReadBufferRect( size_type host_row_pitch, size_type host_slice_pitch, void *ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9668,6 +10450,35 @@ inline cl_int enqueueReadBufferRect( event); } +inline cl_int enqueueReadBufferRect( + const Buffer& buffer, + cl_bool blocking, + const array& buffer_offset, + const array& host_offset, + const array& region, + size_type buffer_row_pitch, + size_type buffer_slice_pitch, + size_type host_row_pitch, + size_type host_slice_pitch, + void* ptr, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueReadBufferRect( + buffer, + blocking, + { buffer_offset[0], buffer_offset[1], 0 }, + { host_offset[0], host_offset[1], 0 }, + { region[0], region[1], 1 }, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); +} + inline cl_int enqueueWriteBufferRect( const Buffer& buffer, cl_bool blocking, @@ -9679,8 +10490,8 @@ inline cl_int enqueueWriteBufferRect( size_type host_row_pitch, size_type host_slice_pitch, const void *ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9704,6 +10515,35 @@ inline cl_int enqueueWriteBufferRect( event); } +inline cl_int enqueueWriteBufferRect( + const Buffer& buffer, + cl_bool blocking, + const array& buffer_offset, + const array& host_offset, + const array& region, + size_type buffer_row_pitch, + size_type buffer_slice_pitch, + size_type host_row_pitch, + size_type host_slice_pitch, + const void* ptr, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueWriteBufferRect( + buffer, + blocking, + { buffer_offset[0], buffer_offset[1], 0 }, + { host_offset[0], host_offset[1], 0 }, + { region[0], region[1], 1 }, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + events, + event); +} + inline cl_int enqueueCopyBufferRect( const Buffer& src, const Buffer& dst, @@ -9714,8 +10554,8 @@ inline cl_int enqueueCopyBufferRect( size_type src_slice_pitch, size_type dst_row_pitch, size_type dst_slice_pitch, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9737,6 +10577,33 @@ inline cl_int enqueueCopyBufferRect( events, event); } + +inline cl_int enqueueCopyBufferRect( + const Buffer& src, + const Buffer& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + size_type src_row_pitch, + size_type src_slice_pitch, + size_type dst_row_pitch, + size_type dst_slice_pitch, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueCopyBufferRect( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + events, + event); +} #endif // CL_HPP_TARGET_OPENCL_VERSION >= 110 inline cl_int enqueueReadImage( @@ -9747,8 +10614,8 @@ inline cl_int enqueueReadImage( size_type row_pitch, size_type slice_pitch, void* ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9769,6 +10636,29 @@ inline cl_int enqueueReadImage( event); } +inline cl_int enqueueReadImage( + const Image& image, + cl_bool blocking, + const array& origin, + const array& region, + size_type row_pitch, + size_type slice_pitch, + void* ptr, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueReadImage( + image, + blocking, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, + row_pitch, + slice_pitch, + ptr, + events, + event); +} + inline cl_int enqueueWriteImage( const Image& image, cl_bool blocking, @@ -9777,8 +10667,8 @@ inline cl_int enqueueWriteImage( size_type row_pitch, size_type slice_pitch, const void* ptr, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9799,14 +10689,37 @@ inline cl_int enqueueWriteImage( event); } +inline cl_int enqueueWriteImage( + const Image& image, + cl_bool blocking, + const array& origin, + const array& region, + size_type row_pitch, + size_type slice_pitch, + const void* ptr, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueWriteImage( + image, + blocking, + { origin[0], origin[1], 0 }, + { region[0], region[1], 1 }, + row_pitch, + slice_pitch, + ptr, + events, + event); +} + inline cl_int enqueueCopyImage( const Image& src, const Image& dst, const array& src_origin, const array& dst_origin, const array& region, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9825,14 +10738,33 @@ inline cl_int enqueueCopyImage( event); } +inline cl_int enqueueCopyImage( + const Image& src, + const Image& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueCopyImage( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + events, + event); +} + inline cl_int enqueueCopyImageToBuffer( const Image& src, const Buffer& dst, const array& src_origin, const array& region, size_type dst_offset, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9851,14 +10783,33 @@ inline cl_int enqueueCopyImageToBuffer( event); } -inline cl_int enqueueCopyBufferToImage( +inline cl_int enqueueCopyImageToBuffer( + const Image& src, + const Buffer& dst, + const array& src_origin, + const array& region, + size_type dst_offset, + const vector* events = nullptr, + Event* event = nullptr) +{ + return enqueueCopyImageToBuffer( + src, + dst, + { src_origin[0], src_origin[1], 0 }, + { region[0], region[1], 1 }, + dst_offset, + events, + event); +} + +inline cl_int enqueueCopyBufferToImage( const Buffer& src, const Image& dst, size_type src_offset, const array& dst_origin, const array& region, - const vector* events = NULL, - Event* event = NULL) + const vector* events = nullptr, + Event* event = nullptr) { cl_int error; CommandQueue queue = CommandQueue::getDefault(&error); @@ -9877,6 +10828,31 @@ inline cl_int enqueueCopyBufferToImage( event); } +inline cl_int enqueueCopyBufferToImage( + const Buffer& src, + const Image& dst, + size_type src_offset, + const array& dst_origin, + const array& region, + const vector* events = nullptr, + Event* event = nullptr) +{ + cl_int error; + CommandQueue queue = CommandQueue::getDefault(&error); + + if (error != CL_SUCCESS) { + return error; + } + + return enqueueCopyBufferToImage( + src, + dst, + src_offset, + { dst_origin[0], dst_origin[1], 0 }, + { region[0], region[1], 1 }, + events, + event); +} inline cl_int flush(void) { @@ -10125,7 +11101,7 @@ class KernelFunctor KernelFunctor( const Program& program, const string name, - cl_int * err = NULL) : + cl_int * err = nullptr) : kernel_(program, name.c_str(), err) {} @@ -10214,7 +11190,7 @@ namespace compatibility { make_kernel( const Program& program, const string name, - cl_int * err = NULL) : + cl_int * err = nullptr) : functor_(FunctorType(program, name, err)) {} @@ -10241,7 +11217,842 @@ namespace compatibility { }; } // namespace compatibility +#ifdef cl_khr_semaphore + +#ifdef cl_khr_external_semaphore +enum ExternalSemaphoreType : cl_external_semaphore_handle_type_khr +{ + None = 0, +#ifdef cl_khr_external_semaphore_opaque_fd + OpaqueFd = CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR, +#endif // cl_khr_external_semaphore_opaque_fd +#ifdef cl_khr_external_semaphore_sync_fd + SyncFd = CL_SEMAPHORE_HANDLE_SYNC_FD_KHR, +#endif // cl_khr_external_semaphore_sync_fd +#ifdef cl_khr_external_semaphore_win32 + OpaqueWin32 = CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR, + OpaqueWin32Kmt = CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR, +#endif // cl_khr_external_semaphore_win32 +}; +#endif // cl_khr_external_semaphore + +class Semaphore : public detail::Wrapper +{ +public: + Semaphore() : detail::Wrapper() {} + Semaphore( + const Context &context, + const vector& sema_props, + cl_int *err = nullptr) + { + /* initialization of addresses to extension functions (it is done only once) */ + std::call_once(ext_init_, initExtensions, context); + + cl_int error = CL_INVALID_OPERATION; + + if (pfn_clCreateSemaphoreWithPropertiesKHR) + { + object_ = pfn_clCreateSemaphoreWithPropertiesKHR( + context(), + sema_props.data(), + &error); + } + + detail::errHandler(error, __CREATE_SEMAPHORE_KHR_WITH_PROPERTIES_ERR); + + if (err != nullptr) { + *err = error; + } + } + Semaphore( + const vector& sema_props, + cl_int* err = nullptr):Semaphore(Context::getDefault(err), sema_props, err) {} + + explicit Semaphore(const cl_semaphore_khr& semaphore, bool retainObject = false) : + detail::Wrapper(semaphore, retainObject) {} + Semaphore& operator = (const cl_semaphore_khr& rhs) { + detail::Wrapper::operator=(rhs); + return *this; + } + template + cl_int getInfo(cl_semaphore_info_khr name, T* param) const + { + if (pfn_clGetSemaphoreInfoKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __GET_SEMAPHORE_KHR_INFO_ERR); + } + + return detail::errHandler( + detail::getInfo(pfn_clGetSemaphoreInfoKHR, object_, name, param), + __GET_SEMAPHORE_KHR_INFO_ERR); + } + template typename + detail::param_traits::param_type + getInfo(cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_semaphore_info_khr, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != nullptr) { + *err = result; + } + return param; + } + +#ifdef cl_khr_external_semaphore + template + cl_int getHandleForTypeKHR( + const Device& device, cl_external_semaphore_handle_type_khr name, T* param) const + { + if (pfn_clGetSemaphoreHandleForTypeKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __GET_SEMAPHORE_HANDLE_FOR_TYPE_KHR_ERR); + } + + return detail::errHandler( + detail::getInfo( + pfn_clGetSemaphoreHandleForTypeKHR, object_, device(), name, param), + __GET_SEMAPHORE_HANDLE_FOR_TYPE_KHR_ERR); + } + + template typename + detail::param_traits::param_type + getHandleForTypeKHR(const Device& device, cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_external_semaphore_handle_type_khr, type>::param_type param; + cl_int result = getHandleForTypeKHR(device, type, ¶m); + if (err != nullptr) { + *err = result; + } + return param; + } +#endif // cl_khr_external_semaphore + + cl_int retain() + { + if (pfn_clRetainSemaphoreKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __RETAIN_SEMAPHORE_KHR_ERR); + } + return pfn_clRetainSemaphoreKHR(object_); + } + + cl_int release() + { + if (pfn_clReleaseSemaphoreKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __RELEASE_SEMAPHORE_KHR_ERR); + } + return pfn_clReleaseSemaphoreKHR(object_); + } + +private: + static std::once_flag ext_init_; + + static void initExtensions(const Context& context) + { +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + Device device = context.getInfo().at(0); + cl_platform_id platform = device.getInfo()(); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCreateSemaphoreWithPropertiesKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clReleaseSemaphoreKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clRetainSemaphoreKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueWaitSemaphoresKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueSignalSemaphoresKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clGetSemaphoreInfoKHR); +#ifdef cl_khr_external_semaphore + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clGetSemaphoreHandleForTypeKHR); +#endif // cl_khr_external_semaphore + +#else + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateSemaphoreWithPropertiesKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clReleaseSemaphoreKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clRetainSemaphoreKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clEnqueueWaitSemaphoresKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clEnqueueSignalSemaphoresKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetSemaphoreInfoKHR); +#ifdef cl_khr_external_semaphore + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetSemaphoreHandleForTypeKHR); +#endif // cl_khr_external_semaphore + +#endif + if ((pfn_clCreateSemaphoreWithPropertiesKHR == nullptr) && + (pfn_clReleaseSemaphoreKHR == nullptr) && + (pfn_clRetainSemaphoreKHR == nullptr) && + (pfn_clEnqueueWaitSemaphoresKHR == nullptr) && + (pfn_clEnqueueSignalSemaphoresKHR == nullptr) && +#ifdef cl_khr_external_semaphore + (pfn_clGetSemaphoreHandleForTypeKHR == nullptr) && +#endif // cl_khr_external_semaphore + (pfn_clGetSemaphoreInfoKHR == nullptr)) + { + detail::errHandler(CL_INVALID_VALUE, __CREATE_SEMAPHORE_KHR_WITH_PROPERTIES_ERR); + } + } + +}; + +CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag Semaphore::ext_init_; + +inline cl_int CommandQueue::enqueueWaitSemaphores( + const vector &sema_objects, + const vector &sema_payloads, + const vector* events_wait_list, + Event *event) const +{ + cl_event tmp; + cl_int err = CL_INVALID_OPERATION; + + if (pfn_clEnqueueWaitSemaphoresKHR != nullptr) { + err = pfn_clEnqueueWaitSemaphoresKHR( + object_, + (cl_uint)sema_objects.size(), + (const cl_semaphore_khr *) &sema_objects.front(), + (sema_payloads.size() > 0) ? &sema_payloads.front() : nullptr, + (events_wait_list != nullptr) ? (cl_uint) events_wait_list->size() : 0, + (events_wait_list != nullptr && events_wait_list->size() > 0) ? (cl_event*) &events_wait_list->front() : nullptr, + (event != nullptr) ? &tmp : nullptr); + } + + detail::errHandler(err, __ENQUEUE_WAIT_SEMAPHORE_KHR_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; +} + +inline cl_int CommandQueue::enqueueSignalSemaphores( + const vector &sema_objects, + const vector& sema_payloads, + const vector* events_wait_list, + Event* event) +{ + cl_event tmp; + cl_int err = CL_INVALID_OPERATION; + + if (pfn_clEnqueueSignalSemaphoresKHR != nullptr) { + err = pfn_clEnqueueSignalSemaphoresKHR( + object_, + (cl_uint)sema_objects.size(), + (const cl_semaphore_khr*) &sema_objects.front(), + (sema_payloads.size() > 0) ? &sema_payloads.front() : nullptr, + (events_wait_list != nullptr) ? (cl_uint) events_wait_list->size() : 0, + (events_wait_list != nullptr && events_wait_list->size() > 0) ? (cl_event*) &events_wait_list->front() : nullptr, + (event != nullptr) ? &tmp : nullptr); + } + + detail::errHandler(err, __ENQUEUE_SIGNAL_SEMAPHORE_KHR_ERR); + + if (event != nullptr && err == CL_SUCCESS) + *event = tmp; + + return err; +} + +#endif // cl_khr_semaphore + +#if defined(cl_khr_command_buffer) +/*! \class CommandBufferKhr + * \brief CommandBufferKhr interface for cl_command_buffer_khr. + */ +class CommandBufferKhr : public detail::Wrapper +{ +public: + //! \brief Default constructor - initializes to nullptr. + CommandBufferKhr() : detail::Wrapper() { } + + explicit CommandBufferKhr(const vector &queues, + cl_command_buffer_properties_khr properties = 0, + cl_int* errcode_ret = nullptr) + { + cl_command_buffer_properties_khr command_buffer_properties[] = { + CL_COMMAND_BUFFER_FLAGS_KHR, properties, 0 + }; + + /* initialization of addresses to extension functions (it is done only once) */ + std::call_once(ext_init_, [&] { initExtensions(queues[0].getInfo()); }); + cl_int error = CL_INVALID_OPERATION; + + static_assert(sizeof(cl::CommandQueue) == sizeof(cl_command_queue), + "Size of cl::CommandQueue must be equal to size of cl_command_queue"); + + if (pfn_clCreateCommandBufferKHR) + { + object_ = pfn_clCreateCommandBufferKHR((cl_uint) queues.size(), + (cl_command_queue *) &queues.front(), + command_buffer_properties, + &error); + } + + detail::errHandler(error, __CREATE_COMMAND_BUFFER_KHR_ERR); + if (errcode_ret != nullptr) { + *errcode_ret = error; + } + } + + explicit CommandBufferKhr(const cl_command_buffer_khr& commandBufferKhr, bool retainObject = false) : + detail::Wrapper(commandBufferKhr, retainObject) { } + + CommandBufferKhr& operator=(const cl_command_buffer_khr& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_command_buffer_info_khr name, T* param) const + { + if (pfn_clGetCommandBufferInfoKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __GET_COMMAND_BUFFER_INFO_KHR_ERR); + } + return detail::errHandler( + detail::getInfo(pfn_clGetCommandBufferInfoKHR, object_, name, param), + __GET_COMMAND_BUFFER_INFO_KHR_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_command_buffer_info_khr, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != nullptr) { + *err = result; + } + return param; + } + + cl_int finalizeCommandBuffer() const + { + return detail::errHandler(::clFinalizeCommandBufferKHR(object_), __FINALIZE_COMMAND_BUFFER_KHR_ERR); + } + + cl_int enqueueCommandBuffer(vector &queues, + const vector* events = nullptr, + Event* event = nullptr) + { + if (pfn_clEnqueueCommandBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __ENQUEUE_COMMAND_BUFFER_KHR_ERR); + } + + static_assert(sizeof(cl::CommandQueue) == sizeof(cl_command_queue), + "Size of cl::CommandQueue must be equal to size of cl_command_queue"); + + return detail::errHandler(pfn_clEnqueueCommandBufferKHR((cl_uint) queues.size(), + (cl_command_queue *) &queues.front(), + object_, + (events != nullptr) ? (cl_uint) events->size() : 0, + (events != nullptr && events->size() > 0) ? (cl_event*) &events->front() : nullptr, + (cl_event*) event), + __ENQUEUE_COMMAND_BUFFER_KHR_ERR); + } + + cl_int commandBarrierWithWaitList(const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandBarrierWithWaitListKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_BARRIER_WITH_WAIT_LIST_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandBarrierWithWaitListKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_BARRIER_WITH_WAIT_LIST_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandCopyBuffer(const Buffer& src, + const Buffer& dst, + size_type src_offset, + size_type dst_offset, + size_type size, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandCopyBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_COPY_BUFFER_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandCopyBufferKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + src(), + dst(), + src_offset, + dst_offset, + size, + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_COPY_BUFFER_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandCopyBufferRect(const Buffer& src, + const Buffer& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + size_type src_row_pitch, + size_type src_slice_pitch, + size_type dst_row_pitch, + size_type dst_slice_pitch, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandCopyBufferRectKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_COPY_BUFFER_RECT_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandCopyBufferRectKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + src(), + dst(), + src_origin.data(), + dst_origin.data(), + region.data(), + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_COPY_BUFFER_RECT_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandCopyBufferToImage(const Buffer& src, + const Image& dst, + size_type src_offset, + const array& dst_origin, + const array& region, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandCopyBufferToImageKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_COPY_BUFFER_TO_IMAGE_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandCopyBufferToImageKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + src(), + dst(), + src_offset, + dst_origin.data(), + region.data(), + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_COPY_BUFFER_TO_IMAGE_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + return error; + } + + cl_int commandCopyImage(const Image& src, + const Image& dst, + const array& src_origin, + const array& dst_origin, + const array& region, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandCopyImageKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_COPY_IMAGE_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandCopyImageKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + src(), + dst(), + src_origin.data(), + dst_origin.data(), + region.data(), + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_COPY_IMAGE_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandCopyImageToBuffer(const Image& src, + const Buffer& dst, + const array& src_origin, + const array& region, + size_type dst_offset, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandCopyImageToBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_COPY_IMAGE_TO_BUFFER_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandCopyImageToBufferKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + src(), + dst(), + src_origin.data(), + region.data(), + dst_offset, + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_COPY_IMAGE_TO_BUFFER_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + template + cl_int commandFillBuffer(const Buffer& buffer, + PatternType pattern, + size_type offset, + size_type size, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandFillBufferKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_FILL_BUFFER_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandFillBufferKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + buffer(), + static_cast(&pattern), + sizeof(PatternType), + offset, + size, + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_FILL_BUFFER_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandFillImage(const Image& image, + cl_float4 fillColor, + const array& origin, + const array& region, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandFillImageKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_FILL_IMAGE_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandFillImageKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + nullptr, // Properties +#endif + image(), + static_cast(&fillColor), + origin.data(), + region.data(), + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_FILL_IMAGE_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + + cl_int commandNDRangeKernel( +#if CL_KHR_COMMAND_BUFFER_EXTENSION_VERSION > CL_MAKE_VERSION(0, 9, 4) + const cl::vector &properties, +#else + const cl::vector &properties, +#endif + const Kernel& kernel, + const NDRange& offset, + const NDRange& global, + const NDRange& local = NullRange, + const vector* sync_points_vec = nullptr, + cl_sync_point_khr* sync_point = nullptr, + MutableCommandKhr* mutable_handle = nullptr, + const CommandQueue* command_queue = nullptr) + { + if (pfn_clCommandNDRangeKernelKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __COMMAND_NDRANGE_KERNEL_KHR_ERR); + } + + cl_sync_point_khr tmp_sync_point; + cl_int error = detail::errHandler( + pfn_clCommandNDRangeKernelKHR(object_, + (command_queue != nullptr) ? (*command_queue)() : nullptr, + &properties[0], + kernel(), + (cl_uint) global.dimensions(), + offset.dimensions() != 0 ? (const size_type*) offset : nullptr, + (const size_type*) global, + local.dimensions() != 0 ? (const size_type*) local : nullptr, + (sync_points_vec != nullptr) ? (cl_uint) sync_points_vec->size() : 0, + (sync_points_vec != nullptr && sync_points_vec->size() > 0) ? &sync_points_vec->front() : nullptr, + (sync_point != nullptr) ? &tmp_sync_point : nullptr, + (cl_mutable_command_khr*) mutable_handle), + __COMMAND_NDRANGE_KERNEL_KHR_ERR); + + if (sync_point != nullptr && error == CL_SUCCESS) + *sync_point = tmp_sync_point; + + return error; + } + +#if defined(cl_khr_command_buffer_mutable_dispatch) +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION < \ + CL_MAKE_VERSION(0, 9, 2) + cl_int updateMutableCommands(const cl_mutable_base_config_khr* mutable_config) + { + if (pfn_clUpdateMutableCommandsKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __UPDATE_MUTABLE_COMMANDS_KHR_ERR); + } + return detail::errHandler(pfn_clUpdateMutableCommandsKHR(object_, mutable_config), + __UPDATE_MUTABLE_COMMANDS_KHR_ERR); + } +#else + template + cl_int updateMutableCommands(std::array &config_types, + std::array &configs) { + if (pfn_clUpdateMutableCommandsKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __UPDATE_MUTABLE_COMMANDS_KHR_ERR); + } + return detail::errHandler( + pfn_clUpdateMutableCommandsKHR(object_, static_cast(configs.size()), + config_types.data(), configs.data()), + __UPDATE_MUTABLE_COMMANDS_KHR_ERR); + } +#endif /* CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION */ +#endif /* cl_khr_command_buffer_mutable_dispatch */ + +private: + static std::once_flag ext_init_; + + static void initExtensions(const cl::Device& device) + { +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_platform_id platform = device.getInfo()(); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCreateCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clFinalizeCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clRetainCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clReleaseCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clGetCommandBufferInfoKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clEnqueueCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandBarrierWithWaitListKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandCopyBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandCopyBufferRectKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandCopyBufferToImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandCopyImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandCopyImageToBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandFillBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandFillImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clCommandNDRangeKernelKHR); +#if defined(cl_khr_command_buffer_mutable_dispatch) + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clUpdateMutableCommandsKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_(platform, clGetMutableCommandInfoKHR); +#endif /* cl_khr_command_buffer_mutable_dispatch */ +#elif CL_HPP_TARGET_OPENCL_VERSION >= 110 + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCreateCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clFinalizeCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clRetainCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clReleaseCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetCommandBufferInfoKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clEnqueueCommandBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandBarrierWithWaitListKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandCopyBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandCopyBufferRectKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandCopyBufferToImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandCopyImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandCopyImageToBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandFillBufferKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandFillImageKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clCommandNDRangeKernelKHR); +#if defined(cl_khr_command_buffer_mutable_dispatch) + CL_HPP_INIT_CL_EXT_FCN_PTR_(clUpdateMutableCommandsKHR); + CL_HPP_INIT_CL_EXT_FCN_PTR_(clGetMutableCommandInfoKHR); +#endif /* cl_khr_command_buffer_mutable_dispatch */ +#endif + if ((pfn_clCreateCommandBufferKHR == nullptr) && + (pfn_clFinalizeCommandBufferKHR == nullptr) && + (pfn_clRetainCommandBufferKHR == nullptr) && + (pfn_clReleaseCommandBufferKHR == nullptr) && + (pfn_clGetCommandBufferInfoKHR == nullptr) && + (pfn_clEnqueueCommandBufferKHR == nullptr) && + (pfn_clCommandBarrierWithWaitListKHR == nullptr) && + (pfn_clCommandCopyBufferKHR == nullptr) && + (pfn_clCommandCopyBufferRectKHR == nullptr) && + (pfn_clCommandCopyBufferToImageKHR == nullptr) && + (pfn_clCommandCopyImageKHR == nullptr) && + (pfn_clCommandCopyImageToBufferKHR == nullptr) && + (pfn_clCommandFillBufferKHR == nullptr) && + (pfn_clCommandFillImageKHR == nullptr) && + (pfn_clCommandNDRangeKernelKHR == nullptr) +#if defined(cl_khr_command_buffer_mutable_dispatch) + && (pfn_clUpdateMutableCommandsKHR == nullptr) + && (pfn_clGetMutableCommandInfoKHR == nullptr) +#endif /* cl_khr_command_buffer_mutable_dispatch */ + ) + { + detail::errHandler(CL_INVALID_VALUE, __CREATE_COMMAND_BUFFER_KHR_ERR); + } + } +}; // CommandBufferKhr + +CL_HPP_DEFINE_STATIC_MEMBER_ std::once_flag CommandBufferKhr::ext_init_; + +#if defined(cl_khr_command_buffer_mutable_dispatch) +/*! \class MutableCommandKhr + * \brief MutableCommandKhr interface for cl_mutable_command_khr. + */ +class MutableCommandKhr : public detail::Wrapper +{ +public: + //! \brief Default constructor - initializes to nullptr. + MutableCommandKhr() : detail::Wrapper() { } + + explicit MutableCommandKhr(const cl_mutable_command_khr& mutableCommandKhr, bool retainObject = false) : + detail::Wrapper(mutableCommandKhr, retainObject) { } + + MutableCommandKhr& operator=(const cl_mutable_command_khr& rhs) + { + detail::Wrapper::operator=(rhs); + return *this; + } + + template + cl_int getInfo(cl_mutable_command_info_khr name, T* param) const + { + if (pfn_clGetMutableCommandInfoKHR == nullptr) { + return detail::errHandler(CL_INVALID_OPERATION, + __GET_MUTABLE_COMMAND_INFO_KHR_ERR); + } + return detail::errHandler( + detail::getInfo(pfn_clGetMutableCommandInfoKHR, object_, name, param), + __GET_MUTABLE_COMMAND_INFO_KHR_ERR); + } + + template typename + detail::param_traits::param_type + getInfo(cl_int* err = nullptr) const + { + typename detail::param_traits< + detail::cl_mutable_command_info_khr, name>::param_type param; + cl_int result = getInfo(name, ¶m); + if (err != nullptr) { + *err = result; + } + return param; + } +}; // MutableCommandKhr +#endif /* cl_khr_command_buffer_mutable_dispatch */ + +#endif // cl_khr_command_buffer //---------------------------------------------------------------------------------------------------------------------- #undef CL_HPP_ERR_STR_ @@ -10264,8 +12075,26 @@ namespace compatibility { #undef __GET_PROGRAM_BUILD_INFO_ERR #undef __GET_COMMAND_QUEUE_INFO_ERR #undef __CREATE_CONTEXT_ERR -#undef __CREATE_CONTEXT_FROM_TYPE_ERR +#undef __CREATE_CONTEXT_FROM_TYPE_ERR +#undef __CREATE_COMMAND_BUFFER_KHR_ERR +#undef __GET_COMMAND_BUFFER_INFO_KHR_ERR +#undef __FINALIZE_COMMAND_BUFFER_KHR_ERR +#undef __ENQUEUE_COMMAND_BUFFER_KHR_ERR +#undef __COMMAND_BARRIER_WITH_WAIT_LIST_KHR_ERR +#undef __COMMAND_COPY_BUFFER_KHR_ERR +#undef __COMMAND_COPY_BUFFER_RECT_KHR_ERR +#undef __COMMAND_COPY_BUFFER_TO_IMAGE_KHR_ERR +#undef __COMMAND_COPY_IMAGE_KHR_ERR +#undef __COMMAND_COPY_IMAGE_TO_BUFFER_KHR_ERR +#undef __COMMAND_FILL_BUFFER_KHR_ERR +#undef __COMMAND_FILL_IMAGE_KHR_ERR +#undef __COMMAND_NDRANGE_KERNEL_KHR_ERR +#undef __UPDATE_MUTABLE_COMMANDS_KHR_ERR +#undef __GET_MUTABLE_COMMAND_INFO_KHR_ERR +#undef __RETAIN_COMMAND_BUFFER_KHR_ERR +#undef __RELEASE_COMMAND_BUFFER_KHR_ERR #undef __GET_SUPPORTED_IMAGE_FORMATS_ERR +#undef __SET_CONTEXT_DESCTRUCTOR_CALLBACK_ERR #undef __CREATE_BUFFER_ERR #undef __COPY_ERR #undef __CREATE_SUBBUFFER_ERR @@ -10283,7 +12112,6 @@ namespace compatibility { #undef __CREATE_KERNEL_ERR #undef __SET_KERNEL_ARGS_ERR #undef __CREATE_PROGRAM_WITH_SOURCE_ERR -#undef __CREATE_PROGRAM_WITH_IL_ERR #undef __CREATE_PROGRAM_WITH_BINARY_ERR #undef __CREATE_PROGRAM_WITH_IL_ERR #undef __CREATE_PROGRAM_WITH_BUILT_IN_KERNELS_ERR @@ -10307,7 +12135,12 @@ namespace compatibility { #undef __ENQUEUE_FILL_IMAGE_ERR #undef __ENQUEUE_COPY_IMAGE_TO_BUFFER_ERR #undef __ENQUEUE_COPY_BUFFER_TO_IMAGE_ERR -#undef __ENQUEUE_MAP_BUFFER_ERR +#undef __ENQUEUE_MAP_BUFFER_ERR +#undef __ENQUEUE_MAP_IMAGE_ERR +#undef __ENQUEUE_MAP_SVM_ERR +#undef __ENQUEUE_FILL_SVM_ERR +#undef __ENQUEUE_COPY_SVM_ERR +#undef __ENQUEUE_UNMAP_SVM_ERR #undef __ENQUEUE_MAP_IMAGE_ERR #undef __ENQUEUE_UNMAP_MEM_OBJECT_ERR #undef __ENQUEUE_NDRANGE_KERNEL_ERR @@ -10323,8 +12156,9 @@ namespace compatibility { #undef __FLUSH_ERR #undef __FINISH_ERR #undef __VECTOR_CAPACITY_ERR -#undef __CREATE_SUB_DEVICES_ERR -#undef __CREATE_SUB_DEVICES_ERR +#undef __CREATE_SUB_DEVICES_ERR +#undef __ENQUEUE_ACQUIRE_EXTERNAL_MEMORY_ERR +#undef __ENQUEUE_RELEASE_EXTERNAL_MEMORY_ERR #undef __ENQUEUE_MARKER_ERR #undef __ENQUEUE_WAIT_FOR_EVENTS_ERR #undef __ENQUEUE_BARRIER_ERR @@ -10341,18 +12175,22 @@ namespace compatibility { #undef __CLONE_KERNEL_ERR #undef __GET_HOST_TIMER_ERR #undef __GET_DEVICE_AND_HOST_TIMER_ERR +#undef __GET_SEMAPHORE_KHR_INFO_ERR +#undef __CREATE_SEMAPHORE_KHR_WITH_PROPERTIES_ERR +#undef __GET_IMAGE_REQUIREMENT_INFO_EXT_ERR +#undef __ENQUEUE_WAIT_SEMAPHORE_KHR_ERR +#undef __ENQUEUE_SIGNAL_SEMAPHORE_KHR_ERR +#undef __RETAIN_SEMAPHORE_KHR_ERR +#undef __RELEASE_SEMAPHORE_KHR_ERR +#undef __GET_SEMAPHORE_HANDLE_FOR_TYPE_KHR_ERR #endif //CL_HPP_USER_OVERRIDE_ERROR_STRINGS // Extensions +#undef CL_HPP_CREATE_CL_EXT_FCN_PTR_ALIAS_ #undef CL_HPP_INIT_CL_EXT_FCN_PTR_ #undef CL_HPP_INIT_CL_EXT_FCN_PTR_PLATFORM_ -#if defined(CL_HPP_USE_CL_DEVICE_FISSION) -#undef CL_HPP_PARAM_NAME_DEVICE_FISSION_ -#endif // CL_HPP_USE_CL_DEVICE_FISSION - -#undef CL_HPP_NOEXCEPT_ #undef CL_HPP_DEFINE_STATIC_MEMBER_ } // namespace cl diff --git a/deps/opencl-headers-hpp/tests/CMakeLists.txt b/deps/opencl-headers-hpp/tests/CMakeLists.txt index 7f2fab885..5d2661ec1 100644 --- a/deps/opencl-headers-hpp/tests/CMakeLists.txt +++ b/deps/opencl-headers-hpp/tests/CMakeLists.txt @@ -1,148 +1,193 @@ -set(OPENCL_HEADERS_INCLUDE_DIR_GENEXPR $) -############################### -### ### -### Workaround to CMake bug ### -### ### -############################### -# -# The generated mocks\Mockcl.h include the OpenCL headers as -# -# #include "CL/cl_platform.h" -# #include "cl.h" -# -# which requires the tests to not only inherit the INTERFACE_INCLUDE_DIRECTORIES, but also the same dir with -# /CL appended at the end. There seems to be a bug in CMake (3.19 even) where if a target has the same genexpr -# predicate twice, the second time it always fails. Having both -# -# $ (invisbly via linking to OpenCL::Headers) -# $/CL -# -# means we can only get one of these switches. We forcibly go around it by extracting the value manually. -# -# Bug ticket: https://gitlab.kitware.com/cmake/cmake/-/issues/22735 -# -# ticket closed with by-design. We should find a way to fix the Mock tests to not consume the public API using -# mixed style includes. -get_target_property(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES OpenCL::Headers INTERFACE_INCLUDE_DIRECTORIES) - -if(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES MATCHES "BUILD_INTERFACE") - # When building OpenCL::Headers is part of this build (OpenCL-SDK), we have a property like for eg. - # $;$ - # and need to touch up this property. We want the BUILD_INTERFACE part only. - # When OpenCL::Headers is consumed through a Package Config file (OpenCL-CLHPP), this property - # no longer holds unevaluated generator expressions. - string(REGEX MATCHALL - [[\$;]] - OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES - "${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}") - set(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_MATCH_1}") -endif() -# End of workaround - -add_custom_command( - OUTPUT stripped/cl.h - COMMAND ${CMAKE_COMMAND} -E make_directory stripped - COMMAND ${CMAKE_COMMAND} -E make_directory mocks - COMMAND ${CMAKE_COMMAND} -D INPUT="${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl.h" -D OUTPUT="stripped/cl.h" -P ${CMAKE_CURRENT_SOURCE_DIR}/strip_defines.cmake - COMMENT "Stripping defines from cl.h" - DEPENDS ${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl.h strip_defines.cmake) - -add_custom_target( - strip_cl_defines ALL - DEPENDS stripped/cl.h - SOURCES strip_defines.cmake) - -add_custom_command( - OUTPUT mocks/Mockcl.c mocks/Mockcl.h - COMMAND ${RUBY_EXECUTABLE} ${CMOCK_DIR}/lib/cmock.rb -o${CMAKE_CURRENT_SOURCE_DIR}/cmock.yml stripped/cl.h - COMMENT "Generating mocks" - DEPENDS stripped/cl.h cmock.yml) - -add_custom_target( - mock_cl_header ALL - DEPENDS mocks/Mockcl.c mocks/Mockcl.h - SOURCES cmock.yml) - -add_dependencies(mock_cl_header strip_cl_defines) - -add_custom_command( - OUTPUT test_openclhpp_Runner.c - COMMAND ${RUBY_EXECUTABLE} ${UNITY_DIR}/auto/generate_test_runner.rb test_openclhpp.cpp cmock.yml ${CMAKE_CURRENT_BINARY_DIR}/test_openclhpp_Runner.c - WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} - COMMENT "Generating test runner" - DEPENDS test_openclhpp.cpp cmock.yml) - -add_custom_target( - openclhpp_runner ALL - DEPENDS test_openclhpp_Runner.c - SOURCES test_openclhpp.cpp) - -if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_CXX_COMPILER_ID MATCHES "(Apple)?Clang") - add_compile_options(-Wno-deprecated-declarations) -endif() - -add_definitions(-DCL_TARGET_OPENCL_VERSION=300) -add_definitions(-DCL_EXPERIMENTAL) - -add_definitions(-DUNITY_SUPPORT_64) -if( CMAKE_SIZEOF_VOID_P EQUAL 8 ) - add_definitions(-DUNITY_POINTER_WIDTH=64) - add_definitions("-DCMOCK_MEM_PTR_AS_INT=unsigned long long") - add_definitions(-DCMOCK_MEM_ALIGN=3) -endif() -if( CMAKE_SIZEOF_LONG EQUAL 8 ) - add_definitions(-DUNITY_LONG_WIDTH=64) -endif() - -set(TEST_HEADERS - ${PROJECT_SOURCE_DIR}/include/CL/opencl.hpp - mocks/Mockcl.h) - -set(TEST_SOURCES - ${CMAKE_CURRENT_BINARY_DIR}/test_openclhpp_Runner.c - test_openclhpp.cpp - ${CMAKE_CURRENT_BINARY_DIR}/mocks/Mockcl.c - ${CMOCK_DIR}/src/cmock.c - ${UNITY_DIR}/src/unity.c) - -# TODO enable testing for OpenCL 1.0 and 1.1 -foreach(VERSION 120 200 210 220 300) - foreach(OPTION "" CL_HPP_ENABLE_EXCEPTIONS CL_HPP_ENABLE_SIZE_T_COMPATIBILITY CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY CL_HPP_CL_1_2_DEFAULT_BUILD CL_HPP_USE_CL_DEVICE_FISSION CL_HPP_USE_CL_IMAGE2D_FROM_BUFFER_KHR CL_HPP_USE_CL_SUB_GROUPS_KHR CL_HPP_USE_IL_KHR) - if(OPTION STREQUAL "") - # The empty string means we're not setting any special option. - set(UNDERSCORE_OPTION "${OPTION}") - set(DEFINE_OPTION "") - else() - set(UNDERSCORE_OPTION "_${OPTION}") - set(DEFINE_OPTION "-D${OPTION}") - endif() - - set(TEST_EXE test_openclhpp_${VERSION}${UNDERSCORE_OPTION}) - add_executable(${TEST_EXE} ${TEST_SOURCES}) #${TEST_HEADERS}) - target_link_libraries(${TEST_EXE} - PRIVATE - OpenCL::HeadersCpp - OpenCL::Headers - Threads::Threads - ) - target_include_directories(${TEST_EXE} - PRIVATE - ${CMAKE_CURRENT_BINARY_DIR}/mocks - - ${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL - #${OPENCL_HEADERS_INCLUDE_DIR_GENEXPR}/CL - - ${UNITY_DIR}/src - ${CMOCK_DIR}/src - ) - target_compile_definitions(${TEST_EXE} - PUBLIC -DCL_HPP_TARGET_OPENCL_VERSION=${VERSION} ${DEFINE_OPTION} - ) - add_dependencies(${TEST_EXE} - strip_cl_defines - mock_cl_header - openclhpp_runner - ) - add_test(NAME ${TEST_EXE} COMMAND ${TEST_EXE}) - endforeach(OPTION) -endforeach(VERSION) +set(OPENCL_HEADERS_INCLUDE_DIR_GENEXPR $) +############################### +### ### +### Workaround to CMake bug ### +### ### +############################### +# +# The generated mocks\Mockcl.h include the OpenCL headers as +# +# #include "CL/cl_platform.h" +# #include "cl.h" +# +# which requires the tests to not only inherit the INTERFACE_INCLUDE_DIRECTORIES, but also the same dir with +# /CL appended at the end. There seems to be a bug in CMake (3.19 even) where if a target has the same genexpr +# predicate twice, the second time it always fails. Having both +# +# $ (invisbly via linking to OpenCL::Headers) +# $/CL +# +# means we can only get one of these switches. We forcibly go around it by extracting the value manually. +# +# Bug ticket: https://gitlab.kitware.com/cmake/cmake/-/issues/22735 +# +# ticket closed with by-design. We should find a way to fix the Mock tests to not consume the public API using +# mixed style includes. +get_target_property(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES OpenCL::Headers INTERFACE_INCLUDE_DIRECTORIES) + +if(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES MATCHES "BUILD_INTERFACE") + # When building OpenCL::Headers is part of this build (OpenCL-SDK), we have a property like for eg. + # $;$ + # and need to touch up this property. We want the BUILD_INTERFACE part only. + # When OpenCL::Headers is consumed through a Package Config file (OpenCL-CLHPP), this property + # no longer holds unevaluated generator expressions. + string(REGEX MATCHALL + [[\$;]] + OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES + "${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}") + set(OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_MATCH_1}") +endif() +# End of workaround + +add_custom_command( + OUTPUT stripped/cl.h stripped/cl_ext.h stripped/cl_gl.h + COMMAND ${CMAKE_COMMAND} -E make_directory stripped + COMMAND ${CMAKE_COMMAND} -E make_directory mocks + COMMAND ${CMAKE_COMMAND} -D INPUT="${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl.h" -D OUTPUT="stripped/cl.h" -P ${CMAKE_CURRENT_SOURCE_DIR}/strip_defines.cmake + COMMAND ${CMAKE_COMMAND} -D INPUT="${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl_ext.h" -D OUTPUT="stripped/cl_ext.h" -P ${CMAKE_CURRENT_SOURCE_DIR}/strip_defines.cmake + COMMAND ${CMAKE_COMMAND} -D INPUT="${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl_gl.h" -D OUTPUT="stripped/cl_gl.h" -P ${CMAKE_CURRENT_SOURCE_DIR}/strip_defines.cmake + COMMENT "Stripping defines from cl.h, cl_ext.h and cl_gl.h" + DEPENDS ${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL/cl.h strip_defines.cmake) + +add_custom_target( + strip_cl_defines ALL + DEPENDS stripped/cl.h + DEPENDS stripped/cl_ext.h + DEPENDS stripped/cl_gl.h + SOURCES strip_defines.cmake) + +add_custom_command( + OUTPUT mocks/Mockcl.c mocks/Mockcl.h mocks/Mockcl_ext.c mocks/Mockcl_ext.h mocks/Mockcl_gl.c mocks/Mockcl_gl.h + COMMAND ${RUBY_EXECUTABLE} ${CMOCK_DIR}/lib/cmock.rb -o${CMAKE_CURRENT_SOURCE_DIR}/cmock.yml stripped/cl.h + COMMAND ${RUBY_EXECUTABLE} ${CMOCK_DIR}/lib/cmock.rb -o${CMAKE_CURRENT_SOURCE_DIR}/cmock.yml stripped/cl_ext.h + COMMAND ${RUBY_EXECUTABLE} ${CMOCK_DIR}/lib/cmock.rb -o${CMAKE_CURRENT_SOURCE_DIR}/cmock.yml stripped/cl_gl.h + COMMENT "Generating mocks" + DEPENDS stripped/cl.h stripped/cl_ext.h stripped/cl_gl.h cmock.yml) + +add_custom_target( + mock_cl_header ALL + DEPENDS mocks/Mockcl.c mocks/Mockcl.h + DEPENDS mocks/Mockcl_ext.c mocks/Mockcl_ext.h + DEPENDS mocks/Mockcl_gl.c mocks/Mockcl_gl.h + SOURCES cmock.yml) + +add_dependencies(mock_cl_header strip_cl_defines) + +add_custom_command( + OUTPUT test_openclhpp_Runner.c + COMMAND ${RUBY_EXECUTABLE} ${UNITY_DIR}/auto/generate_test_runner.rb test_openclhpp.cpp cmock.yml ${CMAKE_CURRENT_BINARY_DIR}/test_openclhpp_Runner.c + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMENT "Generating test runner" + DEPENDS test_openclhpp.cpp cmock.yml) + +add_custom_target( + openclhpp_runner ALL + DEPENDS test_openclhpp_Runner.c + SOURCES test_openclhpp.cpp) + +if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_CXX_COMPILER_ID MATCHES "(Apple)?Clang") + add_compile_options(-Wno-deprecated-declarations) +elseif(MSVC) + add_compile_options(/wd4996) +endif() + +add_definitions(-DCL_TARGET_OPENCL_VERSION=300) +add_definitions(-DCL_EXPERIMENTAL) + +add_definitions(-DUNITY_SUPPORT_64) +if( CMAKE_SIZEOF_VOID_P EQUAL 8 ) + add_definitions(-DUNITY_POINTER_WIDTH=64) + add_definitions("-DCMOCK_MEM_PTR_AS_INT=unsigned long long") + add_definitions(-DCMOCK_MEM_ALIGN=3) +endif() +if( CMAKE_SIZEOF_LONG EQUAL 8 ) + add_definitions(-DUNITY_LONG_WIDTH=64) +endif() + +set(TEST_HEADERS + ${PROJECT_SOURCE_DIR}/include/CL/opencl.hpp + mocks/Mockcl.h + mocks/Mockcl_ext.h + mocks/Mockcl_gl.h) + +set(TEST_SOURCES + ${CMAKE_CURRENT_BINARY_DIR}/test_openclhpp_Runner.c + test_openclhpp.cpp + ${CMAKE_CURRENT_BINARY_DIR}/mocks/Mockcl.c + ${CMAKE_CURRENT_BINARY_DIR}/mocks/Mockcl_ext.c + ${CMAKE_CURRENT_BINARY_DIR}/mocks/Mockcl_gl.c + ${CMOCK_DIR}/src/cmock.c + ${UNITY_DIR}/src/unity.c) + +# TODO enable testing for OpenCL 1.0 and 1.1 +foreach(VERSION 120 200 210 220 300) + foreach(OPTION "" CL_HPP_ENABLE_EXCEPTIONS CL_HPP_ENABLE_SIZE_T_COMPATIBILITY CL_HPP_ENABLE_PROGRAM_CONSTRUCTION_FROM_ARRAY_COMPATIBILITY CL_HPP_CL_1_2_DEFAULT_BUILD CL_HPP_USE_CL_SUB_GROUPS_KHR CL_HPP_USE_IL_KHR) + if(OPTION STREQUAL "") + # The empty string means we're not setting any special option. + set(UNDERSCORE_OPTION "${OPTION}") + set(DEFINE_OPTION "") + else() + set(UNDERSCORE_OPTION "_${OPTION}") + set(DEFINE_OPTION "-D${OPTION}") + endif() + + set(TEST_EXE test_openclhpp_${VERSION}${UNDERSCORE_OPTION}) + add_executable(${TEST_EXE} ${TEST_SOURCES}) #${TEST_HEADERS}) + target_link_libraries(${TEST_EXE} + PRIVATE + OpenCL::HeadersCpp + OpenCL::Headers + Threads::Threads + ) + target_include_directories(${TEST_EXE} + PRIVATE + ${CMAKE_CURRENT_BINARY_DIR}/mocks + + ${OPENCL_HEADERS_INTERFACE_INCLUDE_DIRECTORIES}/CL + #${OPENCL_HEADERS_INCLUDE_DIR_GENEXPR}/CL + + ${UNITY_DIR}/src + ${CMOCK_DIR}/src + ) + target_compile_definitions(${TEST_EXE} + PUBLIC -DCL_HPP_TARGET_OPENCL_VERSION=${VERSION} ${DEFINE_OPTION} + ) + if(MSVC AND (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")) + # This is quite hacky, but the definition noreturn in Clang's + # stdnoreturn.h is not compatible with stdlib.h in the Windows SDK. + # This could normally be resolved by changing the order of include + # files, but not possible in this project due to the generated nature + # of the source files. + target_compile_definitions(${TEST_EXE} PRIVATE __STDNORETURN_H UNITY_NORETURN=_Noreturn) + endif() + add_dependencies(${TEST_EXE} + strip_cl_defines + mock_cl_header + openclhpp_runner + ) + add_test(NAME ${TEST_EXE} COMMAND ${TEST_EXE}) + endforeach(OPTION) +endforeach(VERSION) + +if(NOT TARGET OpenCL::openCL) + find_package(OpenCLICDLoader) +endif() +if(TARGET OpenCL::OpenCL) + # TODO enable testing for OpenCL 1.0 and 1.1 + foreach(MINVERSION 120 200 210 220 300) + foreach(TARGETVERSION 120 200 210 220 300) + if(NOT (${MINVERSION} GREATER ${TARGETVERSION})) + set(TEST_EXE test_openclhpp_version_min_${MINVERSION}_target_${TARGETVERSION}) + add_executable(${TEST_EXE} test_versions.cpp) + target_compile_definitions(${TEST_EXE} PUBLIC + CL_HPP_MINIMUM_OPENCL_VERSION=${MINVERSION} + CL_HPP_TARGET_OPENCL_VERSION=${TARGETVERSION}) + target_link_libraries(${TEST_EXE} PRIVATE + OpenCL::HeadersCpp + OpenCL::Headers + OpenCL::OpenCL) + add_test(NAME ${TEST_EXE} COMMAND ${TEST_EXE}) + endif() + endforeach() + endforeach() +endif() \ No newline at end of file diff --git a/deps/opencl-headers-hpp/tests/ToAdd.txt b/deps/opencl-headers-hpp/tests/ToAdd.txt index 2c82af680..0d073dc6e 100644 --- a/deps/opencl-headers-hpp/tests/ToAdd.txt +++ b/deps/opencl-headers-hpp/tests/ToAdd.txt @@ -1,8 +1,8 @@ -Test for create program from binaries. -Tests for linkProgram. -Tests for SVM - - enableFineGrainedSystemSVM - setSVMPointers - SVM setArg variants - SVM allocators - SVM shared pointer +Test for create program from binaries. +Tests for linkProgram. +Tests for SVM - + enableFineGrainedSystemSVM + setSVMPointers + SVM setArg variants + SVM allocators + SVM shared pointer diff --git a/deps/opencl-headers-hpp/tests/cmock.yml b/deps/opencl-headers-hpp/tests/cmock.yml index 7783c6b1d..0cd67b535 100644 --- a/deps/opencl-headers-hpp/tests/cmock.yml +++ b/deps/opencl-headers-hpp/tests/cmock.yml @@ -5,6 +5,7 @@ :enforce_strict_ordering: :true :c_calling_conventions: - CL_API_CALL + - CL_CALLBACK :plugins: - :callback :treat_as: diff --git a/deps/opencl-headers-hpp/tests/pkgconfig/bare/CMakeLists.txt b/deps/opencl-headers-hpp/tests/pkgconfig/bare/CMakeLists.txt index e535f4ecc..077cdf2d6 100644 --- a/deps/opencl-headers-hpp/tests/pkgconfig/bare/CMakeLists.txt +++ b/deps/opencl-headers-hpp/tests/pkgconfig/bare/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES CXX diff --git a/deps/opencl-headers-hpp/tests/pkgconfig/sdk/CMakeLists.txt b/deps/opencl-headers-hpp/tests/pkgconfig/sdk/CMakeLists.txt index f331b1361..9421fb072 100644 --- a/deps/opencl-headers-hpp/tests/pkgconfig/sdk/CMakeLists.txt +++ b/deps/opencl-headers-hpp/tests/pkgconfig/sdk/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES CXX diff --git a/deps/opencl-headers-hpp/tests/strip_defines.cmake b/deps/opencl-headers-hpp/tests/strip_defines.cmake index a2a973a26..4741fcb80 100644 --- a/deps/opencl-headers-hpp/tests/strip_defines.cmake +++ b/deps/opencl-headers-hpp/tests/strip_defines.cmake @@ -7,7 +7,7 @@ endif() file(READ "${INPUT}" INPUT_STRING) string(REGEX REPLACE - [[CL_(API_ENTRY|API_SUFFIX|EXT|CALLBACK)[A-Za-z0-9_]*]] + [[CL_(API_ENTRY|API_SUFFIX|EXT)[A-Za-z0-9_]*]] "" TMP_STRING "${INPUT_STRING}" diff --git a/deps/opencl-headers-hpp/tests/test_openclhpp.cpp b/deps/opencl-headers-hpp/tests/test_openclhpp.cpp index ea179fa3e..28e5d55d2 100644 --- a/deps/opencl-headers-hpp/tests/test_openclhpp.cpp +++ b/deps/opencl-headers-hpp/tests/test_openclhpp.cpp @@ -12,6 +12,8 @@ extern "C" #include #include #include "Mockcl.h" +#include "Mockcl_ext.h" +#include "Mockcl_gl.h" #include #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0])) @@ -53,9 +55,28 @@ static inline cl_program make_program(int index) return (cl_program)(size_t)(0xcfcfcfcf + index); } -/* Pools of pre-allocated wrapped objects for tests. There is no device pool, - * because there is no way to know whether the test wants the device to be - * reference countable or not. +static inline cl_command_buffer_khr make_command_buffer_khr(int index) +{ + return (cl_command_buffer_khr)(size_t)(0x8f8f8f8f + index); +} + +static inline cl_mutable_command_khr make_mutable_command_khr(int index) { + return (cl_mutable_command_khr)(size_t)(0x77777777 + index); +} + +static inline cl_event make_event(int index) +{ + return (cl_event)(size_t)(0xd0d0d0d0 + index); +} + +#if defined(cl_khr_semaphore) +static inline cl_semaphore_khr make_semaphore_khr(int index) +{ + return (cl_semaphore_khr)(size_t)(0xa0b0c0e0 + index); +} +#endif + +/* Pools of pre-allocated wrapped objects for tests. */ static const int POOL_MAX = 5; static cl::Platform platformPool[POOL_MAX]; @@ -65,11 +86,19 @@ static cl::Buffer bufferPool[POOL_MAX]; static cl::Image2D image2DPool[POOL_MAX]; static cl::Image3D image3DPool[POOL_MAX]; static cl::Kernel kernelPool[POOL_MAX]; +static cl::Program programPool[POOL_MAX]; +#if defined(cl_khr_command_buffer) +static cl::CommandBufferKhr commandBufferKhrPool[POOL_MAX]; +static cl::MutableCommandKhr mutableCommandKhrPool[POOL_MAX]; +#endif +#if defined(cl_khr_semaphore) +static cl::Semaphore semaphorePool[POOL_MAX]; +#endif +static cl::Device devicePool[POOL_MAX]; /**************************************************************************** * Stub functions shared by multiple tests ****************************************************************************/ - /** * Stub implementation of clGetCommandQueueInfo that returns the first context. */ @@ -81,14 +110,15 @@ static cl_int clGetCommandQueueInfo_context( size_t *param_value_size_ret, int num_calls) { - (void)num_calls; + (void) id; + (void) num_calls; TEST_ASSERT_EQUAL_HEX(CL_QUEUE_CONTEXT, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= sizeof(cl_context)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_context)); + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_context); - if (param_value != NULL) + if (param_value != nullptr) *(cl_context *)param_value = make_context(0); return CL_SUCCESS; @@ -105,13 +135,14 @@ static cl_int clGetDeviceInfo_platform( size_t *param_value_size_ret, int num_calls) { + (void) id; (void) num_calls; TEST_ASSERT_EQUAL_HEX(CL_DEVICE_PLATFORM, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= sizeof(cl_platform_id)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_platform_id)); + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_platform_id); - if (param_value != NULL) + if (param_value != nullptr) *(cl_platform_id *) param_value = make_platform_id(0); return CL_SUCCESS; } @@ -127,13 +158,14 @@ static cl_int clGetContextInfo_device( size_t *param_value_size_ret, int num_calls) { + (void) id; (void) num_calls; TEST_ASSERT_EQUAL_HEX(CL_CONTEXT_DEVICES, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= sizeof(cl_device_id)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_device_id)); + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_device_id); - if (param_value != NULL) + if (param_value != nullptr) *(cl_device_id *) param_value = make_device_id(0); return CL_SUCCESS; } @@ -156,10 +188,10 @@ static cl_int clGetPlatformInfo_version( TEST_ASSERT_NOT_NULL(id); TEST_ASSERT_EQUAL_PTR(make_platform_id(0), id); TEST_ASSERT_EQUAL_HEX(CL_PLATFORM_VERSION, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= bytes); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= bytes); + if (param_value_size_ret != nullptr) *param_value_size_ret = bytes; - if (param_value != NULL) + if (param_value != nullptr) strcpy((char *) param_value, version); return CL_SUCCESS; } @@ -218,6 +250,7 @@ static cl_int clGetPlatformInfo_version_2_0( param_value_size_ret, "OpenCL 2.0 Mock"); } +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 /** * A stub for clGetPlatformInfo that will only support querying * CL_PLATFORM_VERSION, and will return version 3.0. @@ -235,6 +268,7 @@ static cl_int clGetPlatformInfo_version_3_0( id, param_name, param_value_size, param_value, param_value_size_ret, "OpenCL 3.0 Mock"); } +#endif /* Simulated reference counts. The table points to memory held by the caller. * This makes things simpler in the common case of only one object to be @@ -243,13 +277,13 @@ static cl_int clGetPlatformInfo_version_3_0( class RefcountTable { private: - int n; // number of objects + size_t n; // number of objects void * const *objects; // object IDs int *refcounts; // current refcounts - int find(void *object) + size_t find(void *object) { - int idx = 0; + size_t idx = 0; while (idx < n && objects[idx] != object) idx++; TEST_ASSERT(idx < n); @@ -258,30 +292,30 @@ class RefcountTable } public: - RefcountTable() : n(0), objects(NULL), refcounts(NULL) {} + RefcountTable() : n(0), objects(nullptr), refcounts(nullptr) {} - void init(int n, void * const *objects, int *refcounts) + void init(size_t n_, void * const *objects_, int *refcounts_) { - this->n = n; - this->objects = objects; - this->refcounts = refcounts; + n = n_; + objects = objects_; + refcounts = refcounts_; } void reset() { - init(0, NULL, NULL); + init(0, nullptr, nullptr); } cl_int retain(void *object) { - int idx = find(object); + size_t idx = find(object); ++refcounts[idx]; return CL_SUCCESS; } cl_int release(void *object) { - int idx = find(object); + size_t idx = find(object); --refcounts[idx]; return CL_SUCCESS; } @@ -306,16 +340,21 @@ class RefcountTable (void) num_calls; \ return table.release(object); \ } \ - static void prepare_ ## table(int n, cl_type const *objects, int *refcounts) \ + static void prepare_ ## table(size_t n, cl_type const *objects, int *refcounts) \ { \ table.init(n, (void * const *) objects, refcounts); \ retainfunc ## _StubWithCallback(retainfunc ## _refcount); \ releasefunc ## _StubWithCallback(releasefunc ## _refcount); \ } +MAKE_REFCOUNT_STUBS(cl_program, clRetainProgram, clReleaseProgram, programRefcounts) +MAKE_REFCOUNT_STUBS(cl_command_queue, clRetainCommandQueue, clReleaseCommandQueue, commandQueueRefcounts) MAKE_REFCOUNT_STUBS(cl_device_id, clRetainDevice, clReleaseDevice, deviceRefcounts) MAKE_REFCOUNT_STUBS(cl_context, clRetainContext, clReleaseContext, contextRefcounts) MAKE_REFCOUNT_STUBS(cl_mem, clRetainMemObject, clReleaseMemObject, memRefcounts) +#if defined(cl_khr_command_buffer) +MAKE_REFCOUNT_STUBS(cl_command_buffer_khr, clRetainCommandBufferKHR, clReleaseCommandBufferKHR, commandBufferKhrRefcounts) +#endif /* The indirection through MAKE_MOVE_TESTS2 with a prefix parameter is to * prevent the simple-minded parser from Unity from identifying tests from the @@ -323,7 +362,7 @@ MAKE_REFCOUNT_STUBS(cl_mem, clRetainMemObject, clReleaseMemObject, memRefcounts) */ #ifdef TEST_RVALUE_REFERENCES #define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \ - void prefix ## MoveAssign ## type ## NonNull() \ + void prefix ## MoveAssign ## type ## NonNull(void) \ { \ releaseFunc ## _ExpectAndReturn(makeFunc(0), CL_SUCCESS); \ pool[0] = std::move(pool[1]); \ @@ -331,23 +370,23 @@ MAKE_REFCOUNT_STUBS(cl_mem, clRetainMemObject, clReleaseMemObject, memRefcounts) TEST_ASSERT_NULL(pool[1]()); \ } \ \ - void prefix ## MoveAssign ## type ## Null() \ + void prefix ## MoveAssign ## type ## Null(void) \ { \ - pool[0]() = NULL; \ + pool[0]() = nullptr; \ pool[0] = std::move(pool[1]); \ TEST_ASSERT_EQUAL_PTR(makeFunc(1), pool[0]()); \ TEST_ASSERT_NULL(pool[1]()); \ } \ \ - void prefix ## MoveConstruct ## type ## NonNull() \ + void prefix ## MoveConstruct ## type ## NonNull(void) \ { \ cl::type tmp(std::move(pool[0])); \ TEST_ASSERT_EQUAL_PTR(makeFunc(0), tmp()); \ TEST_ASSERT_NULL(pool[0]()); \ - tmp() = NULL; \ + tmp() = nullptr; \ } \ \ - void prefix ## MoveConstruct ## type ## Null() \ + void prefix ## MoveConstruct ## type ## Null(void) \ { \ cl::type empty; \ cl::type tmp(std::move(empty)); \ @@ -356,16 +395,52 @@ MAKE_REFCOUNT_STUBS(cl_mem, clRetainMemObject, clReleaseMemObject, memRefcounts) } #else #define MAKE_MOVE_TESTS2(prefix, type, makeFunc, releaseFunc, pool) \ - void prefix ## MoveAssign ## type ## NonNull() {} \ - void prefix ## MoveAssign ## type ## Null() {} \ - void prefix ## MoveConstruct ## type ## NonNull() {} \ - void prefix ## MoveConstruct ## type ## Null() {} + void prefix ## MoveAssign ## type ## NonNull(void) {} \ + void prefix ## MoveAssign ## type ## Null(void) {} \ + void prefix ## MoveConstruct ## type ## NonNull(void) {} \ + void prefix ## MoveConstruct ## type ## Null(void) {} #endif // !TEST_RVALUE_REFERENCES #define MAKE_MOVE_TESTS(type, makeFunc, releaseFunc, pool) \ MAKE_MOVE_TESTS2(test, type, makeFunc, releaseFunc, pool) -void setUp() +void setUp(void) { + /* init extensions addresses with mocked functions */ +#if defined(cl_khr_command_buffer) + cl::pfn_clCreateCommandBufferKHR = ::clCreateCommandBufferKHR; + cl::pfn_clFinalizeCommandBufferKHR = ::clFinalizeCommandBufferKHR; + cl::pfn_clRetainCommandBufferKHR = ::clRetainCommandBufferKHR; + cl::pfn_clReleaseCommandBufferKHR = ::clReleaseCommandBufferKHR; + cl::pfn_clGetCommandBufferInfoKHR = ::clGetCommandBufferInfoKHR; +#endif +#if defined(cl_khr_command_buffer_mutable_dispatch) + cl::pfn_clUpdateMutableCommandsKHR = ::clUpdateMutableCommandsKHR; + cl::pfn_clGetMutableCommandInfoKHR = ::clGetMutableCommandInfoKHR; +#endif +#if defined(cl_khr_semaphore) + cl::pfn_clCreateSemaphoreWithPropertiesKHR = ::clCreateSemaphoreWithPropertiesKHR; + cl::pfn_clReleaseSemaphoreKHR = ::clReleaseSemaphoreKHR; + cl::pfn_clRetainSemaphoreKHR = ::clRetainSemaphoreKHR; + cl::pfn_clEnqueueWaitSemaphoresKHR = ::clEnqueueWaitSemaphoresKHR; + cl::pfn_clEnqueueSignalSemaphoresKHR = ::clEnqueueSignalSemaphoresKHR; + cl::pfn_clGetSemaphoreInfoKHR = ::clGetSemaphoreInfoKHR; +#endif +#if defined(cl_khr_external_semaphore) + cl::pfn_clGetSemaphoreHandleForTypeKHR = ::clGetSemaphoreHandleForTypeKHR; +#endif +#ifdef cl_khr_external_memory + cl::pfn_clEnqueueAcquireExternalMemObjectsKHR = ::clEnqueueAcquireExternalMemObjectsKHR; + cl::pfn_clEnqueueReleaseExternalMemObjectsKHR = ::clEnqueueReleaseExternalMemObjectsKHR; +#endif + +#if defined(cl_ext_image_requirements_info) + cl::pfn_clGetImageRequirementsInfoEXT = ::clGetImageRequirementsInfoEXT; +#endif + +#if defined(cl_ext_device_fission) + cl::pfn_clCreateSubDevicesEXT = ::clCreateSubDevicesEXT; +#endif + /* We reach directly into the objects rather than using assignment to * avoid the reference counting functions from being called. */ @@ -378,33 +453,74 @@ void setUp() image2DPool[i]() = make_mem(i); image3DPool[i]() = make_mem(i); kernelPool[i]() = make_kernel(i); + programPool[i]() = make_program(i); +#if defined(cl_khr_command_buffer) + commandBufferKhrPool[i]() = make_command_buffer_khr(i); +#endif +#if defined(cl_khr_command_buffer_mutable_dispatch) + mutableCommandKhrPool[i]() = make_mutable_command_khr(i); +#endif +#if defined(cl_khr_semaphore) + semaphorePool[i]() = make_semaphore_khr(i); +#endif + devicePool[i]() = make_device_id(i); } + programRefcounts.reset(); deviceRefcounts.reset(); contextRefcounts.reset(); memRefcounts.reset(); } -void tearDown() +void tearDown(void) { /* Wipe out the internal state to avoid a release call being made */ for (int i = 0; i < POOL_MAX; i++) { - platformPool[i]() = NULL; - contextPool[i]() = NULL; - commandQueuePool[i]() = NULL; - bufferPool[i]() = NULL; - image2DPool[i]() = NULL; - image3DPool[i]() = NULL; - kernelPool[i]() = NULL; + platformPool[i]() = nullptr; + contextPool[i]() = nullptr; + commandQueuePool[i]() = nullptr; + bufferPool[i]() = nullptr; + image2DPool[i]() = nullptr; + image3DPool[i]() = nullptr; + kernelPool[i]() = nullptr; + programPool[i]() = nullptr; + devicePool[i]() = nullptr; +#if defined(cl_khr_command_buffer) + commandBufferKhrPool[i]() = nullptr; + mutableCommandKhrPool[i]() = nullptr; +#endif +#if defined(cl_khr_semaphore) + semaphorePool[i]() = nullptr; +#endif } + +#if defined(cl_khr_command_buffer) + cl::pfn_clCreateCommandBufferKHR = nullptr; + cl::pfn_clFinalizeCommandBufferKHR = nullptr; + cl::pfn_clRetainCommandBufferKHR = nullptr; + cl::pfn_clReleaseCommandBufferKHR = nullptr; + cl::pfn_clGetCommandBufferInfoKHR = nullptr; +#endif +#if defined(cl_khr_semaphore) + cl::pfn_clCreateSemaphoreWithPropertiesKHR = nullptr; + cl::pfn_clReleaseSemaphoreKHR = nullptr; + cl::pfn_clRetainSemaphoreKHR = nullptr; + cl::pfn_clEnqueueWaitSemaphoresKHR = nullptr; + cl::pfn_clEnqueueSignalSemaphoresKHR = nullptr; + cl::pfn_clGetSemaphoreInfoKHR = nullptr; +#endif +#ifdef cl_khr_external_memory + cl::pfn_clEnqueueAcquireExternalMemObjectsKHR = nullptr; + cl::pfn_clEnqueueReleaseExternalMemObjectsKHR = nullptr; +#endif } /**************************************************************************** * Tests for cl::Context ****************************************************************************/ -void testCopyContextNonNull() +void testCopyContextNonNull(void) { clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); @@ -413,10 +529,10 @@ void testCopyContextNonNull() TEST_ASSERT_EQUAL_PTR(make_context(1), contextPool[0]()); } -void testMoveAssignContextNonNull(); -void testMoveAssignContextNull(); -void testMoveConstructContextNonNull(); -void testMoveConstructContextNull(); +void testMoveAssignContextNonNull(void); +void testMoveAssignContextNull(void); +void testMoveConstructContextNonNull(void); +void testMoveConstructContextNull(void); MAKE_MOVE_TESTS(Context, make_context, clReleaseContext, contextPool) /// Stub for querying CL_CONTEXT_DEVICES that returns two devices @@ -431,10 +547,10 @@ static cl_int clGetContextInfo_testContextGetDevices( (void) num_calls; TEST_ASSERT_EQUAL_PTR(make_context(0), context); TEST_ASSERT_EQUAL_HEX(CL_CONTEXT_DEVICES, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= 2 * sizeof(cl_device_id)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= 2 * sizeof(cl_device_id)); + if (param_value_size_ret != nullptr) *param_value_size_ret = 2 * sizeof(cl_device_id); - if (param_value != NULL) + if (param_value != nullptr) { cl_device_id *devices = (cl_device_id *) param_value; devices[0] = make_device_id(0); @@ -444,7 +560,7 @@ static cl_int clGetContextInfo_testContextGetDevices( } /// Test that queried devices are not refcounted -void testContextGetDevices1_1() +void testContextGetDevices1_1(void) { clGetContextInfo_StubWithCallback(clGetContextInfo_testContextGetDevices); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -457,7 +573,7 @@ void testContextGetDevices1_1() } /// Test that queried devices are correctly refcounted -void testContextGetDevices1_2() +void testContextGetDevices1_2(void) { clGetContextInfo_StubWithCallback(clGetContextInfo_testContextGetDevices); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -472,10 +588,11 @@ void testContextGetDevices1_2() TEST_ASSERT_EQUAL_PTR(make_device_id(1), devices[1]()); // Prevent release in the destructor - devices[0]() = NULL; - devices[1]() = NULL; + devices[0]() = nullptr; + devices[1]() = nullptr; } +#if !defined(__APPLE__) && !defined(__MACOS) // This is used to get a list of all platforms, so expect two calls // First, return to say we have two platforms // Then return the two platform id_s @@ -506,7 +623,9 @@ static cl_int clGetPlatformIDs_testContextFromType( return CL_INVALID_VALUE; } } +#endif +#if !defined(__APPLE__) && !defined(__MACOS) // Expect three calls to this // 1. Platform 1, we have no GPUs // 2. Platform 2, we have two GPUs @@ -550,6 +669,7 @@ static cl_int clGetDeviceIDs_testContextFromType( return CL_INVALID_VALUE; } } +#endif // Stub for clCreateContextFromType // - expect platform 1 with GPUs and non-null properties @@ -564,18 +684,24 @@ static cl_context clCreateContextFromType_testContextFromType( cl_int *errcode_ret, int num_calls) { + (void) pfn_notify; + (void) user_data; + (void) num_calls; + TEST_ASSERT_EQUAL(CL_DEVICE_TYPE_GPU, device_type); #if !defined(__APPLE__) && !defined(__MACOS) TEST_ASSERT_NOT_NULL(properties); TEST_ASSERT_EQUAL(CL_CONTEXT_PLATFORM, properties[0]); TEST_ASSERT_EQUAL(make_platform_id(1), properties[1]); +#else + (void) properties; #endif if (errcode_ret) *errcode_ret = CL_SUCCESS; return make_context(0); } -void testContextFromType() +void testContextFromType(void) { #if !defined(__APPLE__) && !defined(__MACOS) clGetPlatformIDs_StubWithCallback(clGetPlatformIDs_testContextFromType); @@ -602,7 +728,7 @@ void testContextFromType() clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); } -void testContextFromTypeNonNullProperties() +void testContextFromTypeNonNullProperties(void) { clCreateContextFromType_StubWithCallback(clCreateContextFromType_testContextFromType); @@ -623,17 +749,21 @@ static cl_context clCreateContext_testContextNonNullProperties( cl_int *errcode_ret, int num_calls) { + (void) pfn_notify; + (void) user_data; + (void) num_calls; + TEST_ASSERT_NOT_NULL(properties); TEST_ASSERT_GREATER_THAN(0, num_devices); - for (int i = 0; i < num_devices; i++) { + for (int i = 0; i < (int)num_devices; i++) { TEST_ASSERT_EQUAL(make_device_id(i), devices[i]); } - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_context(0); } -void testContextWithDeviceNonNullProperties() +void testContextWithDeviceNonNullProperties(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -648,7 +778,7 @@ void testContextWithDeviceNonNullProperties() TEST_ASSERT_EQUAL_PTR(make_context(0), context()); } -void testContextWithDevicesNonNullProperties() +void testContextWithDevicesNonNullProperties(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -668,11 +798,11 @@ void testContextWithDevicesNonNullProperties() * Tests for cl::CommandQueue ****************************************************************************/ -void testMoveAssignCommandQueueNonNull(); -void testMoveAssignCommandQueueNull(); -void testMoveConstructCommandQueueNonNull(); -void testMoveConstructCommandQueueNull(); -MAKE_MOVE_TESTS(CommandQueue, make_command_queue, clReleaseCommandQueue, commandQueuePool); +void testMoveAssignCommandQueueNonNull(void); +void testMoveAssignCommandQueueNull(void); +void testMoveConstructCommandQueueNonNull(void); +void testMoveConstructCommandQueueNull(void); +MAKE_MOVE_TESTS(CommandQueue, make_command_queue, clReleaseCommandQueue, commandQueuePool) // Stub for clGetCommandQueueInfo that returns context 0 static cl_int clGetCommandQueueInfo_testCommandQueueGetContext( @@ -686,15 +816,15 @@ static cl_int clGetCommandQueueInfo_testCommandQueueGetContext( (void) num_calls; TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queue); TEST_ASSERT_EQUAL_HEX(CL_QUEUE_CONTEXT, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= sizeof(cl_context)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_context)); + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_context); - if (param_value != NULL) + if (param_value != nullptr) *(cl_context *) param_value = make_context(0); return CL_SUCCESS; } -void testCommandQueueGetContext() +void testCommandQueueGetContext(void) { cl_context expected = make_context(0); int refcount = 1; @@ -706,7 +836,7 @@ void testCommandQueueGetContext() TEST_ASSERT_EQUAL_PTR(expected, ctx()); TEST_ASSERT_EQUAL(2, refcount); - ctx() = NULL; + ctx() = nullptr; } // Stub for clGetCommandQueueInfo that returns device 0 @@ -721,15 +851,15 @@ static cl_int clGetCommandQueueInfo_testCommandQueueGetDevice( (void) num_calls; TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queue); TEST_ASSERT_EQUAL_HEX(CL_QUEUE_DEVICE, param_name); - TEST_ASSERT(param_value == NULL || param_value_size >= sizeof(cl_device_id)); - if (param_value_size_ret != NULL) + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_device_id)); + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_device_id); - if (param_value != NULL) + if (param_value != nullptr) *(cl_device_id *) param_value = make_device_id(0); return CL_SUCCESS; } -void testCommandQueueGetDevice1_1() +void testCommandQueueGetDevice1_1(void) { cl_device_id expected = make_device_id(0); @@ -740,10 +870,10 @@ void testCommandQueueGetDevice1_1() cl::Device device = commandQueuePool[0].getInfo(); TEST_ASSERT_EQUAL_PTR(expected, device()); - device() = NULL; + device() = nullptr; } -void testCommandQueueGetDevice1_2() +void testCommandQueueGetDevice1_2(void) { cl_device_id expected = make_device_id(0); int refcount = 1; @@ -757,9 +887,10 @@ void testCommandQueueGetDevice1_2() TEST_ASSERT_EQUAL_PTR(expected, device()); TEST_ASSERT_EQUAL(2, refcount); - device() = NULL; + device() = nullptr; } +#if CL_HPP_TARGET_OPENCL_VERSION < 200 // stub for clCreateCommandQueue - returns queue zero static cl_command_queue clCreateCommandQueue_testCommandQueueFromSpecifiedContext( cl_context context, @@ -772,12 +903,11 @@ static cl_command_queue clCreateCommandQueue_testCommandQueueFromSpecifiedContex TEST_ASSERT_EQUAL_PTR(make_context(0), context); TEST_ASSERT_EQUAL_PTR(make_device_id(0), device); TEST_ASSERT(properties == 0); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_command_queue(0); } - -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +#else // stub for clCreateCommandQueueWithProperties - returns queue zero static cl_command_queue clCreateCommandQueueWithProperties_testCommandQueueFromSpecifiedContext( cl_context context, @@ -791,13 +921,13 @@ static cl_command_queue clCreateCommandQueueWithProperties_testCommandQueueFromS TEST_ASSERT_EQUAL_PTR(make_device_id(0), device); TEST_ASSERT(properties[0] == CL_QUEUE_PROPERTIES); TEST_ASSERT(properties[1] == 0); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_command_queue(0); } -#endif // #if CL_HPP_TARGET_OPENCL_VERSION >= 200 +#endif // #if CL_HPP_TARGET_OPENCL_VERSION < 200 -void testCommandQueueFromSpecifiedContext() +void testCommandQueueFromSpecifiedContext(void) { cl_command_queue expected = make_command_queue(0); cl_context expected_context = make_context(0); @@ -842,7 +972,7 @@ void testCommandQueueFromSpecifiedContext() * Tests for cl::Device ****************************************************************************/ -void testCopyDeviceNonNull1_1() +void testCopyDeviceNonNull1_1(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -852,7 +982,7 @@ void testCopyDeviceNonNull1_1() d0 = d1; } -void testCopyDeviceNonNull1_2() +void testCopyDeviceNonNull1_2(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); @@ -864,11 +994,11 @@ void testCopyDeviceNonNull1_2() d0 = d1; // Prevent destructor from interfering with the test - d0() = NULL; - d1() = NULL; + d0() = nullptr; + d1() = nullptr; } -void testCopyDeviceFromNull1_1() +void testCopyDeviceFromNull1_1(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -878,7 +1008,7 @@ void testCopyDeviceFromNull1_1() d = cl::Device(); } -void testCopyDeviceFromNull1_2() +void testCopyDeviceFromNull1_2(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); @@ -888,7 +1018,7 @@ void testCopyDeviceFromNull1_2() d = cl::Device(); } -void testCopyDeviceToNull1_1() +void testCopyDeviceToNull1_1(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -899,7 +1029,7 @@ void testCopyDeviceToNull1_1() d0 = d1; } -void testCopyDeviceToNull1_2() +void testCopyDeviceToNull1_2(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); @@ -910,11 +1040,11 @@ void testCopyDeviceToNull1_2() d0 = d1; // Prevent destructor from interfering with the test - d0() = NULL; - d1() = NULL; + d0() = nullptr; + d1() = nullptr; } -void testCopyDeviceSelf() +void testCopyDeviceSelf(void) { // Use 1.2 to check the retain/release calls clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -927,11 +1057,11 @@ void testCopyDeviceSelf() d0 = d1; // Prevent destructor from interfering with the test - d0() = NULL; - d1() = NULL; + d0() = nullptr; + d1() = nullptr; } -void testAssignDeviceNull() +void testAssignDeviceNull(void) { // Any version will do here clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -939,13 +1069,13 @@ void testAssignDeviceNull() clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); cl::Device d(make_device_id(0)); - d = (cl_device_id) NULL; + d = (cl_device_id) nullptr; } // These tests do not use the MAKE_MOVE_TESTS helper because they need to // check whether the device is reference-countable, and to check that // the reference-countable flag is correctly moved. -void testMoveAssignDeviceNonNull() +void testMoveAssignDeviceNonNull(void) { #ifdef TEST_RVALUE_REFERENCES clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -961,11 +1091,11 @@ void testMoveAssignDeviceNonNull() TEST_ASSERT_NULL(src()); // Prevent destructor from interfering with the test - trg() = NULL; + trg() = nullptr; #endif } -void testMoveAssignDeviceNull() +void testMoveAssignDeviceNull(void) { #ifdef TEST_RVALUE_REFERENCES clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -978,11 +1108,11 @@ void testMoveAssignDeviceNull() TEST_ASSERT_NULL(src()); // Prevent destructor from interfering with the test - trg() = NULL; + trg() = nullptr; #endif } -void testMoveConstructDeviceNonNull() +void testMoveConstructDeviceNonNull(void) { #ifdef TEST_RVALUE_REFERENCES clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -994,11 +1124,11 @@ void testMoveConstructDeviceNonNull() TEST_ASSERT_NULL(src()); // Prevent destructor from interfering with the test - trg() = NULL; + trg() = nullptr; #endif } -void testMoveConstructDeviceNull() +void testMoveConstructDeviceNull(void) { #ifdef TEST_RVALUE_REFERENCES cl::Device empty; @@ -1008,7 +1138,7 @@ void testMoveConstructDeviceNull() #endif } -void testDestroyDevice1_1() +void testDestroyDevice1_1(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); @@ -1017,7 +1147,7 @@ void testDestroyDevice1_1() cl::Device d(make_device_id(0)); } -void testDestroyDevice1_2() +void testDestroyDevice1_2(void) { clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); @@ -1034,6 +1164,9 @@ static cl_int clGetDeviceIDs_PlatformWithZeroDevices( cl_uint *num_devices, int num_calls) { + (void) num_entries; + (void) devices; + if (num_calls == 0) { TEST_ASSERT_EQUAL_PTR(make_platform_id(0), platform); @@ -1048,7 +1181,7 @@ static cl_int clGetDeviceIDs_PlatformWithZeroDevices( } } -void testPlatformWithZeroDevices() +void testPlatformWithZeroDevices(void) { clGetDeviceIDs_StubWithCallback(clGetDeviceIDs_PlatformWithZeroDevices); @@ -1064,11 +1197,11 @@ void testPlatformWithZeroDevices() * Tests for cl::Buffer ****************************************************************************/ -void testMoveAssignBufferNonNull(); -void testMoveAssignBufferNull(); -void testMoveConstructBufferNonNull(); -void testMoveConstructBufferNull(); -MAKE_MOVE_TESTS(Buffer, make_mem, clReleaseMemObject, bufferPool); +void testMoveAssignBufferNonNull(void); +void testMoveAssignBufferNull(void); +void testMoveConstructBufferNonNull(void); +void testMoveConstructBufferNull(void); +MAKE_MOVE_TESTS(Buffer, make_mem, clReleaseMemObject, bufferPool) // Stub of clCreateBuffer for testBufferConstructorContextInterator // - return the first memory location @@ -1081,9 +1214,10 @@ static cl_mem clCreateBuffer_testBufferConstructorContextIterator( cl_int *errcode_ret, int num_calls) { + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(make_context(0), context); - TEST_ASSERT_BITS(CL_MEM_COPY_HOST_PTR, flags, !CL_MEM_COPY_HOST_PTR); - TEST_ASSERT_BITS(CL_MEM_READ_ONLY, flags, CL_MEM_READ_ONLY); + TEST_ASSERT_EQUAL(flags, CL_MEM_READ_ONLY); TEST_ASSERT_EQUAL(sizeof(int)*1024, size); TEST_ASSERT_NULL(host_ptr); if (errcode_ret) @@ -1123,7 +1257,7 @@ static cl_int clReleaseEvent_testCopyHostToBuffer( cl_event event, int num_calls); -void testBufferConstructorContextIterator() +void testBufferConstructorContextIterator(void) { cl_mem expected = make_mem(0); @@ -1163,7 +1297,7 @@ void testBufferConstructorContextIterator() clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); } -void testBufferConstructorQueueIterator() +void testBufferConstructorQueueIterator(void) { cl_context expected_context = make_context(0); int context_refcount = 1; @@ -1192,6 +1326,47 @@ void testBufferConstructorQueueIterator() clReleaseCommandQueue_ExpectAndReturn(make_command_queue(0), CL_SUCCESS); } +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 +static cl_mem clCreateBufferWithProperties_testBufferWithProperties( + cl_context context, + const cl_mem_properties *properties, + cl_mem_flags flags, + size_t size, + void *host_ptr, + cl_int *errcode_ret, + int num_calls) +{ + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(contextPool[0](), context); + TEST_ASSERT_NOT_NULL(properties); + TEST_ASSERT_EQUAL(11, *properties); + TEST_ASSERT_EQUAL(0, flags); + TEST_ASSERT_EQUAL(0, size); + TEST_ASSERT_NULL(host_ptr); + if (errcode_ret) + *errcode_ret = CL_SUCCESS; + + return make_mem(0); +} +#endif //CL_HPP_TARGET_OPENCL_VERSION >= 300 + +void testBufferWithProperties(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + clCreateBufferWithProperties_StubWithCallback(clCreateBufferWithProperties_testBufferWithProperties); + + VECTOR_CLASS props{11}; + cl_int err; + cl::Buffer buffer(contextPool[0], props, 0, 0, nullptr, &err); + + TEST_ASSERT_EQUAL_PTR(make_mem(0), buffer()); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + + // prevent destructor from interfering with the test + buffer() = nullptr; +#endif //CL_HPP_TARGET_OPENCL_VERSION >= 300 +} + /**************************************************************************** * Tests for cl::Image1DBuffer ****************************************************************************/ @@ -1210,16 +1385,16 @@ cl_int clGetImageInfo_testGetImageInfoBuffer( TEST_ASSERT_EQUAL_HEX(CL_IMAGE_BUFFER, param_name); TEST_ASSERT_EQUAL(sizeof(cl_mem), param_value_size); - if (param_value != NULL) + if (param_value != nullptr) { *(cl_mem *) param_value = make_mem(1); } - if (param_value_size_ret != NULL) + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_mem); return CL_SUCCESS; } -void testGetImageInfoBuffer() +void testGetImageInfoBuffer(void) { #if CL_HPP_TARGET_OPENCL_VERSION >= 200 cl_mem expected = make_mem(1); @@ -1235,12 +1410,12 @@ void testGetImageInfoBuffer() TEST_ASSERT_EQUAL(2, refcount); // prevent destructor from interfering with the test - image() = NULL; + image() = nullptr; #endif } /** - * Stub for querying CL_IMAGE_BUFFER and returning NULL. + * Stub for querying CL_IMAGE_BUFFER and returning nullptr. */ cl_int clGetImageInfo_testGetImageInfoBufferNull( cl_mem image, cl_image_info param_name, @@ -1253,16 +1428,16 @@ cl_int clGetImageInfo_testGetImageInfoBufferNull( TEST_ASSERT_EQUAL_HEX(CL_IMAGE_BUFFER, param_name); TEST_ASSERT_EQUAL(sizeof(cl_mem), param_value_size); - if (param_value != NULL) + if (param_value != nullptr) { - *(cl_mem *) param_value = NULL; + *(cl_mem *) param_value = nullptr; } - if (param_value_size_ret != NULL) + if (param_value_size_ret != nullptr) *param_value_size_ret = sizeof(cl_mem); return CL_SUCCESS; } -void testGetImageInfoBufferNull() +void testGetImageInfoBufferNull(void) { #if CL_HPP_TARGET_OPENCL_VERSION >= 200 clGetImageInfo_StubWithCallback(clGetImageInfo_testGetImageInfoBufferNull); @@ -1272,11 +1447,11 @@ void testGetImageInfoBufferNull() TEST_ASSERT_NULL(buffer()); // prevent destructor from interfering with the test - image() = NULL; + image() = nullptr; #endif } -void testGetImageInfoBufferOverwrite() +void testGetImageInfoBufferOverwrite(void) { clGetImageInfo_StubWithCallback(clGetImageInfo_testGetImageInfoBuffer); clReleaseMemObject_ExpectAndReturn(make_mem(2), CL_SUCCESS); @@ -1289,8 +1464,8 @@ void testGetImageInfoBufferOverwrite() TEST_ASSERT_EQUAL_PTR(make_mem(1), buffer()); // prevent destructor from interfering with the test - image() = NULL; - buffer() = NULL; + image() = nullptr; + buffer() = nullptr; } /** @@ -1306,18 +1481,23 @@ cl_mem clCreateImage_image1dbuffer( cl_int *errcode_ret, int num_calls) { + (void) context; + (void) flags; + (void) host_ptr; + (void) num_calls; + TEST_ASSERT_NOT_NULL(image_format); TEST_ASSERT_NOT_NULL(image_desc); TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE1D_BUFFER, image_desc->image_type); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; // Return the passed buffer as the cl_mem return image_desc->buffer; } -void testConstructImageFromBuffer() +void testConstructImageFromBuffer(void) { #if CL_HPP_TARGET_OPENCL_VERSION >= 120 const size_t width = 64; @@ -1339,7 +1519,7 @@ void testConstructImageFromBuffer() // Check that returned buffer matches the original TEST_ASSERT_EQUAL_PTR(buffer(), image()); - buffer() = NULL; + buffer() = nullptr; #endif } @@ -1347,11 +1527,11 @@ void testConstructImageFromBuffer() * Tests for cl::Image2D ****************************************************************************/ -void testMoveAssignImage2DNonNull(); -void testMoveAssignImage2DNull(); -void testMoveConstructImage2DNonNull(); -void testMoveConstructImage2DNull(); -MAKE_MOVE_TESTS(Image2D, make_mem, clReleaseMemObject, image2DPool); +void testMoveAssignImage2DNonNull(void); +void testMoveAssignImage2DNull(void); +void testMoveConstructImage2DNonNull(void); +void testMoveConstructImage2DNull(void); +MAKE_MOVE_TESTS(Image2D, make_mem, clReleaseMemObject, image2DPool) #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS static cl_mem clCreateImage2D_testCreateImage2D_1_1( @@ -1378,13 +1558,13 @@ static cl_mem clCreateImage2D_testCreateImage2D_1_1( TEST_ASSERT_EQUAL(256, image_row_pitch); TEST_ASSERT_NULL(host_ptr); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_mem(0); } #endif -void testCreateImage2D_1_1() +void testCreateImage2D_1_1(void) { #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS clGetContextInfo_StubWithCallback(clGetContextInfo_device); @@ -1397,13 +1577,13 @@ void testCreateImage2D_1_1() context() = make_context(0); cl::Image2D image( context, CL_MEM_READ_WRITE, - cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 256, NULL, &err); + cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 256, nullptr, &err); TEST_ASSERT_EQUAL(CL_SUCCESS, err); TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); - context() = NULL; - image() = NULL; + context() = nullptr; + image() = nullptr; #endif } @@ -1435,12 +1615,12 @@ static cl_mem clCreateImage_testCreateImage2D_1_2( TEST_ASSERT_NULL(host_ptr); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_mem(0); } -void testCreateImage2D_1_2() +void testCreateImage2D_1_2(void) { clGetContextInfo_StubWithCallback(clGetContextInfo_device); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -1452,24 +1632,73 @@ void testCreateImage2D_1_2() context() = make_context(0); cl::Image2D image( context, CL_MEM_READ_WRITE, - cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 256, NULL, &err); + cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 256, nullptr, &err); TEST_ASSERT_EQUAL(CL_SUCCESS, err); TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); - context() = NULL; - image() = NULL; + context() = nullptr; + image() = nullptr; +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 +static cl_mem clCreateImageWithProperties_testImage2DWithProperties( + cl_context context, const cl_mem_properties *properties, cl_mem_flags flags, + const cl_image_format *image_format, const cl_image_desc *image_desc, + void *host_ptr, cl_int *errcode_ret, int num_calls) { + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(contextPool[0](), context); + TEST_ASSERT_NOT_NULL(properties); + TEST_ASSERT_EQUAL(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR, properties[0]); + TEST_ASSERT_EQUAL(42, properties[1]); + TEST_ASSERT_EQUAL(0, properties[2]); + TEST_ASSERT_EQUAL(CL_MEM_READ_WRITE, flags); + TEST_ASSERT_NOT_NULL(image_format); + TEST_ASSERT_EQUAL(CL_RGBA, image_format->image_channel_order); + TEST_ASSERT_EQUAL(CL_UNORM_INT8, image_format->image_channel_data_type); + TEST_ASSERT_NOT_NULL(image_desc); + TEST_ASSERT_EQUAL(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + TEST_ASSERT_EQUAL(32, image_desc->image_width); + TEST_ASSERT_EQUAL(16, image_desc->image_height); + TEST_ASSERT_EQUAL(8, image_desc->image_row_pitch); + + TEST_ASSERT_NULL(host_ptr); + if (errcode_ret) + *errcode_ret = CL_SUCCESS; + + return make_mem(0); +} +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 + +void testImage2DWithProperties(void) { +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + clCreateImageWithProperties_StubWithCallback( + clCreateImageWithProperties_testImage2DWithProperties); + + VECTOR_CLASS props = { + CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR, 42, 0}; + cl_int err; + cl::Image2D image(contextPool[0], props, CL_MEM_READ_WRITE, + cl::ImageFormat(CL_RGBA, CL_UNORM_INT8), 32, 16, 8, nullptr, + &err); + + TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + + // prevent destructor from interfering with the test + image() = nullptr; +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 } /**************************************************************************** * Tests for cl::Image3D ****************************************************************************/ -void testMoveAssignImage3DNonNull(); -void testMoveAssignImage3DNull(); -void testMoveConstructImage3DNonNull(); -void testMoveConstructImage3DNull(); -MAKE_MOVE_TESTS(Image3D, make_mem, clReleaseMemObject, image3DPool); +void testMoveAssignImage3DNonNull(void); +void testMoveAssignImage3DNull(void); +void testMoveConstructImage3DNonNull(void); +void testMoveConstructImage3DNull(void); +MAKE_MOVE_TESTS(Image3D, make_mem, clReleaseMemObject, image3DPool) #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS static cl_mem clCreateImage3D_testCreateImage3D_1_1( @@ -1498,15 +1727,15 @@ static cl_mem clCreateImage3D_testCreateImage3D_1_1( TEST_ASSERT_EQUAL(16, image_depth); TEST_ASSERT_EQUAL(256, image_row_pitch); TEST_ASSERT_EQUAL(65536, image_slice_pitch); - TEST_ASSERT_EQUAL_PTR((void *) 0xdeadbeef, host_ptr); + TEST_ASSERT_EQUAL_PTR((void *)(size_t)0xdeadbeef, host_ptr); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_mem(0); } #endif -void testCreateImage3D_1_1() +void testCreateImage3D_1_1(void) { #ifdef CL_USE_DEPRECATED_OPENCL_1_1_APIS clGetContextInfo_StubWithCallback(clGetContextInfo_device); @@ -1519,13 +1748,13 @@ void testCreateImage3D_1_1() context() = make_context(0); cl::Image3D image( context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, - cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 16, 256, 65536, (void *) 0xdeadbeef, &err); + cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 16, 256, 65536, (void *)(size_t)0xdeadbeef, &err); TEST_ASSERT_EQUAL(CL_SUCCESS, err); TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); - context() = NULL; - image() = NULL; + context() = nullptr; + image() = nullptr; #endif } @@ -1557,14 +1786,14 @@ static cl_mem clCreateImage_testCreateImage3D_1_2( TEST_ASSERT_EQUAL(0, image_desc->num_samples); TEST_ASSERT_NULL(image_desc->buffer); - TEST_ASSERT_EQUAL_PTR((void *) 0xdeadbeef, host_ptr); + TEST_ASSERT_EQUAL_PTR((void *)(size_t)0xdeadbeef, host_ptr); - if (errcode_ret != NULL) + if (errcode_ret != nullptr) *errcode_ret = CL_SUCCESS; return make_mem(0); } -void testCreateImage3D_1_2() +void testCreateImage3D_1_2(void) { clGetContextInfo_StubWithCallback(clGetContextInfo_device); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -1576,35 +1805,130 @@ void testCreateImage3D_1_2() context() = make_context(0); cl::Image3D image( context, CL_MEM_READ_WRITE | CL_MEM_COPY_HOST_PTR, - cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 16, 256, 65536, (void *) 0xdeadbeef, &err); + cl::ImageFormat(CL_R, CL_FLOAT), 64, 32, 16, 256, 65536, (void *)(size_t)0xdeadbeef, &err); TEST_ASSERT_EQUAL(CL_SUCCESS, err); TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); - context() = NULL; - image() = NULL; + context() = nullptr; + image() = nullptr; +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 +static cl_mem clCreateImageWithProperties_testImage3DWithProperties( + cl_context context, const cl_mem_properties *properties, cl_mem_flags flags, + const cl_image_format *image_format, const cl_image_desc *image_desc, + void *host_ptr, cl_int *errcode_ret, int num_calls) { + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(contextPool[0](), context); + TEST_ASSERT_NOT_NULL(properties); + TEST_ASSERT_EQUAL(CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR, properties[0]); + TEST_ASSERT_EQUAL(42, properties[1]); + TEST_ASSERT_EQUAL(0, properties[2]); + TEST_ASSERT_EQUAL(CL_MEM_READ_WRITE, flags); + TEST_ASSERT_NOT_NULL(image_format); + TEST_ASSERT_EQUAL(CL_RGBA, image_format->image_channel_order); + TEST_ASSERT_EQUAL(CL_UNORM_INT8, image_format->image_channel_data_type); + TEST_ASSERT_NOT_NULL(image_desc); + TEST_ASSERT_EQUAL(CL_MEM_OBJECT_IMAGE3D, image_desc->image_type); + TEST_ASSERT_EQUAL(32, image_desc->image_width); + TEST_ASSERT_EQUAL(16, image_desc->image_height); + TEST_ASSERT_EQUAL(8, image_desc->image_depth); + TEST_ASSERT_EQUAL(4, image_desc->image_row_pitch); + TEST_ASSERT_EQUAL(2, image_desc->image_slice_pitch); + TEST_ASSERT_NULL(host_ptr); + if (errcode_ret) + *errcode_ret = CL_SUCCESS; + + return make_mem(0); +} +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 + +void testImage3DWithProperties(void) { +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + clCreateImageWithProperties_StubWithCallback( + clCreateImageWithProperties_testImage3DWithProperties); + + VECTOR_CLASS props = { + CL_EXTERNAL_MEMORY_HANDLE_OPAQUE_FD_KHR, 42, 0}; + cl_int err; + cl::Image3D image(contextPool[0], props, CL_MEM_READ_WRITE, + cl::ImageFormat(CL_RGBA, CL_UNORM_INT8), 32, 16, 8, 4, 2, + nullptr, &err); + + TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + + // prevent destructor from interfering with the test + image() = nullptr; +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 } /**************************************************************************** * Tests for cl::Kernel ****************************************************************************/ -void testMoveAssignKernelNonNull(); -void testMoveAssignKernelNull(); -void testMoveConstructKernelNonNull(); -void testMoveConstructKernelNull(); -MAKE_MOVE_TESTS(Kernel, make_kernel, clReleaseKernel, kernelPool); +void testMoveAssignKernelNonNull(void); +void testMoveAssignKernelNull(void); +void testMoveConstructKernelNonNull(void); +void testMoveConstructKernelNull(void); +MAKE_MOVE_TESTS(Kernel, make_kernel, clReleaseKernel, kernelPool) static cl_int scalarArg; static cl_int3 vectorArg; -void testKernelSetArgScalar() +static cl_kernel clCreateKernel_constructor( + cl_program program, + const char* kernel_name, + cl_int* errcode_ret, + int num_calls) +{ + (void) num_calls; + + TEST_ASSERT_EQUAL(program, make_program(0)); + TEST_ASSERT_EQUAL_STRING(kernel_name, "test"); + if (errcode_ret != nullptr) + *errcode_ret = CL_SUCCESS; + + return make_kernel(0); +} + +void testKernelConstructor(void) +{ + clCreateKernel_StubWithCallback(clCreateKernel_constructor); + + cl_int errorCode; + cl::Program program(make_program(0)); + cl::Kernel kernel(program, "test", &errorCode); + TEST_ASSERT_EQUAL(kernel(), make_kernel(0)); + TEST_ASSERT_EQUAL(errorCode, CL_SUCCESS); + + program() = nullptr; + kernel() = nullptr; +} + +void testKernelStringConstructor(void) +{ + clCreateKernel_StubWithCallback(clCreateKernel_constructor); + + cl_int errorCode; + cl::string kernelName("test"); + cl::Program program(make_program(0)); + cl::Kernel kernel(program, kernelName, &errorCode); + TEST_ASSERT_EQUAL(kernel(), make_kernel(0)); + TEST_ASSERT_EQUAL(errorCode, CL_SUCCESS); + + program() = nullptr; + kernel() = nullptr; +} + +void testKernelSetArgScalar(void) { scalarArg = 0xcafebabe; clSetKernelArg_ExpectAndReturn(make_kernel(0), 3, 4, &scalarArg, CL_SUCCESS); kernelPool[0].setArg(3, scalarArg); } -void testKernelSetArgVector() +void testKernelSetArgVector(void) { vectorArg.s[0] = 0x12345678; vectorArg.s[1] = 0x23456789; @@ -1613,19 +1937,46 @@ void testKernelSetArgVector() kernelPool[0].setArg(2, vectorArg); } -void testKernelSetArgMem() +void testKernelSetArgMem(void) { clSetKernelArg_ExpectAndReturn(make_kernel(0), 1, sizeof(cl_mem), &bufferPool[1](), CL_SUCCESS); kernelPool[0].setArg(1, bufferPool[1]); } -void testKernelSetArgLocal() +void testKernelSetArgLocal(void) { - clSetKernelArg_ExpectAndReturn(make_kernel(0), 2, 123, NULL, CL_SUCCESS); + clSetKernelArg_ExpectAndReturn(make_kernel(0), 2, 123, nullptr, CL_SUCCESS); kernelPool[0].setArg(2, cl::Local(123)); } -void testKernelSetExecInfo() +void testKernelSetArgBySetKernelArgSVMPointerWithUniquePtrType(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + std::unique_ptr buffer(new int(1000)); + clSetKernelArgSVMPointer_ExpectAndReturn(make_kernel(0), 1, buffer.get(), CL_SUCCESS); + TEST_ASSERT_EQUAL(kernelPool[0].setArg(1, buffer), CL_SUCCESS); +#endif +} + +void testKernelSetArgBySetKernelArgSVMPointerWithVectorType(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + VECTOR_CLASS vec(1000); + clSetKernelArgSVMPointer_ExpectAndReturn(make_kernel(1), 2, vec.data(), CL_SUCCESS); + TEST_ASSERT_EQUAL(kernelPool[1].setArg(2, vec), CL_SUCCESS); +#endif +} + +void testKernelSetArgBySetKernelArgSVMPointerWithPointerType(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + cl_mem *memory = &bufferPool[1](); + clSetKernelArgSVMPointer_ExpectAndReturn(make_kernel(2), 3, &bufferPool[1](), CL_SUCCESS); + TEST_ASSERT_EQUAL(kernelPool[2].setArg(3, memory), CL_SUCCESS); +#endif +} + +void testKernelSetExecInfo(void) { #if CL_HPP_TARGET_OPENCL_VERSION >= 200 cl_bool val = CL_TRUE; @@ -1644,6 +1995,62 @@ void testKernelSetExecInfo() #endif } + +cl_int clSetKernelExecInfo_setSVMPointers(cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void *param_value, int cmock_num_calls) +{ + (void) cmock_num_calls; + + TEST_ASSERT_EQUAL_PTR(make_kernel(0), kernel); + TEST_ASSERT_EQUAL_HEX(CL_KERNEL_EXEC_INFO_SVM_PTRS, param_name); + TEST_ASSERT(param_value_size == 2 * sizeof(void *)); + + int** arr = (int **)param_value; + TEST_ASSERT_EQUAL_PTR(arr[0], 0xaabbccdd); + TEST_ASSERT_EQUAL_PTR(arr[1], 0xddccbbaa); + + return CL_SUCCESS; +} + +void testKernelSetSVMPointers(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clSetKernelExecInfo_StubWithCallback(clSetKernelExecInfo_setSVMPointers); + + cl::vector vec = { (void *)(size_t)0xaabbccdd, (void *)(size_t)0xddccbbaa }; + cl_int ret = kernelPool[0].setSVMPointers(vec); + + cl_int expected = CL_SUCCESS; + TEST_ASSERT_EQUAL_HEX(expected, ret); +#endif +} +cl_int clSetKernelExecInfo_EnableFineGrainedSystemSVM(cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void *param_value, int cmock_num_calls) +{ + (void) cmock_num_calls; + + TEST_ASSERT_EQUAL_PTR(make_kernel(0), kernel); + TEST_ASSERT_EQUAL_HEX(*(cl_bool*)param_value, CL_FALSE); + TEST_ASSERT_EQUAL_HEX(CL_KERNEL_EXEC_INFO_SVM_FINE_GRAIN_SYSTEM,param_name); + TEST_ASSERT(param_value_size == sizeof(cl_bool)); + + return CL_SUCCESS; +} +void testKernelEnableFineGrainedSystemSVM(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clSetKernelExecInfo_StubWithCallback(clSetKernelExecInfo_EnableFineGrainedSystemSVM); + bool svmEnabled = false; + cl_int ret = kernelPool[0].enableFineGrainedSystemSVM(svmEnabled); + cl_int expected = CL_SUCCESS; + TEST_ASSERT_EQUAL_HEX(expected, ret); +#endif +} + /**************************************************************************** * Tests for cl::copy ****************************************************************************/ @@ -1665,6 +2072,11 @@ static void * clEnqueueMapBuffer_testCopyHostToBuffer( cl_int *errcode_ret, int num_calls) { + (void) offset; + (void) num_events_in_wait_list; + (void) event_wait_list; + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queue); TEST_ASSERT_EQUAL_PTR(make_mem(0), buffer); TEST_ASSERT_EQUAL(CL_TRUE, blocking_map); @@ -1675,7 +2087,7 @@ static void * clEnqueueMapBuffer_testCopyHostToBuffer( // Set the return event if (event) - *event = NULL; + *event = nullptr; // Set the return error code if (errcode_ret) @@ -1693,6 +2105,10 @@ static cl_int clEnqueueUnmapMemObject_testCopyHostToBuffer( cl_event *event, int num_calls) { + (void) num_events_in_wait_list; + (void) event_wait_list; + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queue); TEST_ASSERT_EQUAL_PTR(make_mem(0), memobj); TEST_ASSERT_EQUAL_PTR(some_host_memory, mapped_ptr); @@ -1705,6 +2121,8 @@ static cl_int clWaitForEvents_testCopyHostToBuffer( const cl_event *event_list, int num_calls) { + (void) num_calls; + TEST_ASSERT_NOT_NULL(event_list); TEST_ASSERT_EQUAL(1, num_events); return CL_SUCCESS; @@ -1714,11 +2132,13 @@ static cl_int clReleaseEvent_testCopyHostToBuffer( cl_event event, int num_calls) { + (void) num_calls; + TEST_ASSERT_NOT_NULL(event); return CL_SUCCESS; } -void testCopyHostToBuffer() +void testCopyHostToBuffer(void) { cl_context context_expect = make_context(0); int context_refcount = 1; @@ -1766,10 +2186,13 @@ static cl_int clGetDeviceInfo_testGetBuildInfo( size_t *param_value_size_ret, int num_calls) { + (void) device; + (void) num_calls; + TEST_ASSERT_EQUAL(param_name, CL_DEVICE_PLATFORM); TEST_ASSERT_EQUAL(param_value_size, sizeof(cl_platform_id)); - TEST_ASSERT_NOT_EQUAL(param_value, NULL); - TEST_ASSERT_EQUAL(param_value_size_ret, NULL); + TEST_ASSERT_NOT_EQUAL(param_value, nullptr); + TEST_ASSERT_EQUAL(param_value_size_ret, nullptr); cl_platform_id temp = make_platform_id(0); memcpy(param_value, &temp, sizeof(cl_platform_id)); return CL_SUCCESS; @@ -1785,6 +2208,10 @@ static cl_int clGetProgramBuildInfo_testGetBuildInfo( size_t *param_value_size_ret, int num_calls) { + (void) program; + (void) device; + (void) num_calls; + TEST_ASSERT_EQUAL(param_name, CL_PROGRAM_BUILD_LOG); const char returnString[] = @@ -1805,10 +2232,10 @@ static cl_int clGetProgramBuildInfo_testGetBuildInfo( return CL_SUCCESS; } -void testGetBuildInfo() +void testGetBuildInfo(void) { cl_device_id fakeDevice = make_device_id(0); - clGetDeviceInfo_ExpectAndReturn(fakeDevice, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), NULL, NULL, CL_SUCCESS); + clGetDeviceInfo_ExpectAndReturn(fakeDevice, CL_DEVICE_PLATFORM, sizeof(cl_platform_id), nullptr, nullptr, CL_SUCCESS); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_testGetBuildInfo); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); @@ -1819,10 +2246,10 @@ void testGetBuildInfo() cl::Device dev(fakeDevice); cl_int err; - std::string log = prog.getBuildInfo(dev, &err); + cl::string log = prog.getBuildInfo(dev, &err); - prog() = NULL; - dev() = NULL; + prog() = nullptr; + dev() = nullptr; } static cl_int clBuildProgram_testBuildProgram( @@ -1834,12 +2261,16 @@ static cl_int clBuildProgram_testBuildProgram( void * user_data, int num_calls) { + (void) num_calls; + TEST_ASSERT_EQUAL(program, make_program(0)); TEST_ASSERT_NOT_EQUAL(num_devices, 0); - TEST_ASSERT_NOT_EQUAL(device_list, NULL); - TEST_ASSERT_EQUAL(options, NULL); - TEST_ASSERT_EQUAL(pfn_notify, NULL); - TEST_ASSERT_EQUAL(user_data, NULL); + TEST_ASSERT_NOT_EQUAL(device_list, nullptr); + if (options) { + TEST_ASSERT_EQUAL_STRING(options, "-cl-program-build-options"); + } + TEST_ASSERT_EQUAL(pfn_notify, nullptr); + TEST_ASSERT_EQUAL(user_data, nullptr); for (cl_uint i = 0; i < num_devices; i++) { TEST_ASSERT_EQUAL(device_list[i], make_device_id(i)); @@ -1848,11 +2279,10 @@ static cl_int clBuildProgram_testBuildProgram( return CL_SUCCESS; } -void testBuildProgramSingleDevice() +void testBuildProgramSingleDevice(void) { cl_program program = make_program(0); cl_device_id device_id = make_device_id(0); - int sc = 0; // Creating a device queries the platform version: clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); @@ -1877,1163 +2307,3239 @@ void testBuildProgramSingleDevice() TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); } -/** -* Stub implementation of clGetCommandQueueInfo that returns first one image then none -*/ -static cl_int clGetSupportedImageFormats_testGetSupportedImageFormats( - cl_context context, - cl_mem_flags flags, - cl_mem_object_type image_type, - cl_uint num_entries, - cl_image_format *image_formats, - cl_uint *num_image_formats, - int num_calls) -{ - // Catch failure case that causes error in bugzilla 13355: - // returns CL_INVALID_VALUE if flags or image_type are not valid, - // or if num_entries is 0 and image_formats is not NULL. - if (num_entries == 0 && image_formats != NULL) { - return CL_INVALID_VALUE; - } - if (num_entries == 0) { - // If num_entries was 0 this is the query for number - if (num_image_formats) { - if (num_calls == 0) { - *num_image_formats = 1; - } - else { - *num_image_formats = 0; - } - } - } - else { - // Should return something - TEST_ASSERT_NOT_NULL(image_formats); - - // For first call we should return one format here - if (num_calls == 1) { - TEST_ASSERT_EQUAL(num_entries, 1); - image_formats[0] = cl::ImageFormat(CL_RGB, CL_FLOAT); - } - } +void testBuildProgramSingleDeviceWithOptions(void) +{ + cl_program program = make_program(0); + cl_device_id device_id = make_device_id(0); - return CL_SUCCESS; -} + // Creating a device queries the platform version: + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); -void testGetSupportedImageFormats() -{ - cl_context ctx_cl = make_context(0); + clBuildProgram_StubWithCallback(clBuildProgram_testBuildProgram); - clGetSupportedImageFormats_StubWithCallback(clGetSupportedImageFormats_testGetSupportedImageFormats); - clGetSupportedImageFormats_StubWithCallback(clGetSupportedImageFormats_testGetSupportedImageFormats); - clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + // Building the program queries the program build log: + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); - cl::Context ctx(ctx_cl); - std::vector formats; - cl_int ret = CL_SUCCESS; + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); - ret = ctx.getSupportedImageFormats( - CL_MEM_READ_WRITE, - CL_MEM_OBJECT_IMAGE2D, - &formats); - TEST_ASSERT_EQUAL(ret, CL_SUCCESS); - TEST_ASSERT_EQUAL(formats.size(), 1); - ret = ctx.getSupportedImageFormats( - CL_MEM_READ_WRITE, - CL_MEM_OBJECT_IMAGE2D, - &formats); - TEST_ASSERT_EQUAL(formats.size(), 0); - TEST_ASSERT_EQUAL(ret, CL_SUCCESS); + cl::Program prog(program); + cl::Device dev(device_id); + + cl_int errcode = prog.build(dev, "-cl-program-build-options"); + + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); } -void testCreateSubDevice() +void testBuildProgramSingleDeviceWithStringOptions(void) { - // TODO + cl_program program = make_program(0); + cl_device_id device_id = make_device_id(0); + + // Creating a device queries the platform version: + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + + clBuildProgram_StubWithCallback(clBuildProgram_testBuildProgram); + + // Building the program queries the program build log: + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + cl::Device dev(device_id); + + cl::string options("-cl-program-build-options"); + cl_int errcode = prog.build(dev, options); + + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); } -void testGetContextInfoDevices() +static cl_int clGetProgramInfo_forBuildLog( + cl_program program, + cl_program_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret, + int num_calls) { - // TODO + (void) num_calls; + + TEST_ASSERT_EQUAL(program, make_program(0)); + TEST_ASSERT_EQUAL(param_name, CL_PROGRAM_DEVICES); + if (param_value_size) { + TEST_ASSERT_EQUAL(param_value_size, sizeof(cl_device_id)); + TEST_ASSERT_NOT_EQUAL(param_value, nullptr); + *(cl_device_id*)param_value = make_device_id(0); + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_device_id); + } + return CL_SUCCESS; } -static cl_mem clCreateImage_testCreateImage2DFromBuffer_2_0( - cl_context context, - cl_mem_flags flags, - const cl_image_format *image_format, - const cl_image_desc *image_desc, - void *host_ptr, - cl_int *errcode_ret, +static cl_int clCompileProgram_basic( + cl_program program, + cl_uint num_devices, + const cl_device_id * device_list, + const char * options, + cl_uint num_input_headers, + const cl_program * input_headers, + const char ** header_include_names, + void (CL_CALLBACK * pfn_notify)(cl_program program, + void * user_data), + void * user_data, int num_calls) { - TEST_ASSERT_NOT_NULL(image_format); - TEST_ASSERT_NOT_NULL(image_desc); - TEST_ASSERT_NULL(host_ptr); - TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + (void) num_calls; - // Return the passed buffer as the cl_mem and success for the error code - if (errcode_ret) { - *errcode_ret = CL_SUCCESS; + TEST_ASSERT_EQUAL(program, make_program(0)); + TEST_ASSERT_EQUAL(num_devices, 0); + TEST_ASSERT_EQUAL(device_list, nullptr); + if (options) { + TEST_ASSERT_EQUAL_STRING(options, "-cl-program-compile-options"); } - return image_desc->buffer; + TEST_ASSERT_EQUAL(num_input_headers, 0); + TEST_ASSERT_EQUAL(input_headers, nullptr); + TEST_ASSERT_EQUAL(header_include_names, nullptr); + TEST_ASSERT_EQUAL(pfn_notify, nullptr); + TEST_ASSERT_EQUAL(user_data, nullptr); + + return CL_SUCCESS; } -void testCreateImage2DFromBuffer_2_0() +void testCompileProgramBasic(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - clGetContextInfo_StubWithCallback(clGetContextInfo_device); +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_program program = make_program(0); + + clCompileProgram_StubWithCallback(clCompileProgram_basic); + + // Compiling the program queries the program build log: + clGetProgramInfo_StubWithCallback(clGetProgramInfo_forBuildLog); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clCreateImage_StubWithCallback(clCreateImage_testCreateImage2DFromBuffer_2_0); - clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); - cl_int err; - cl::Context context(make_context(0)); + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); - // Create buffer - // Create image from buffer - cl::Buffer buffer(make_mem(0)); - cl::Image2D imageFromBuffer( - context, - cl::ImageFormat(CL_R, CL_FLOAT), buffer, 64, 32, 256, &err); + cl::Program prog(program); + cl_int errcode = prog.compile(); - TEST_ASSERT_EQUAL_PTR(buffer(), imageFromBuffer()); - TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); +#endif +} + +void testCompileProgramWithOptions(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_program program = make_program(0); + + clCompileProgram_StubWithCallback(clCompileProgram_basic); + + // Compiling the program queries the program build log: + clGetProgramInfo_StubWithCallback(clGetProgramInfo_forBuildLog); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + cl_int errcode = prog.compile("-cl-program-compile-options"); - buffer() = NULL; + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); #endif } -static cl_mem clCreateImage_testCreateImage2D_2_0( +void testCompileProgramWithStringOptions(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_program program = make_program(0); + + clCompileProgram_StubWithCallback(clCompileProgram_basic); + + // Compiling the program queries the program build log: + clGetProgramInfo_StubWithCallback(clGetProgramInfo_forBuildLog); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + cl::string options("-cl-program-compile-options"); + cl_int errcode = prog.compile(options); + + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); +#endif +} + +static cl_int clCompileProgram_headers( + cl_program program, + cl_uint num_devices, + const cl_device_id * device_list, + const char * options, + cl_uint num_input_headers, + const cl_program * input_headers, + const char ** header_include_names, + void (CL_CALLBACK * pfn_notify)(cl_program program, + void * user_data), + void * user_data, + int num_calls) +{ + (void) num_calls; + + TEST_ASSERT_EQUAL(program, make_program(0)); + TEST_ASSERT_EQUAL(num_devices, 0); + TEST_ASSERT_EQUAL(device_list, nullptr); + TEST_ASSERT_EQUAL_STRING(options, ""); + TEST_ASSERT_EQUAL(num_input_headers, 2); + TEST_ASSERT_NOT_EQUAL(input_headers, nullptr); + TEST_ASSERT_NOT_EQUAL(header_include_names, nullptr); + TEST_ASSERT_EQUAL(input_headers[0], make_program(1)); + TEST_ASSERT_EQUAL(input_headers[1], make_program(2)); + TEST_ASSERT_EQUAL_STRING(header_include_names[0], "name0"); + TEST_ASSERT_EQUAL_STRING(header_include_names[1], "name1"); + TEST_ASSERT_EQUAL(pfn_notify, nullptr); + TEST_ASSERT_EQUAL(user_data, nullptr); + + return CL_SUCCESS; +} + +void testCompileProgramHeaders(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_program program = make_program(0); + cl_program header0 = make_program(1); + cl_program header1 = make_program(2); + + clCompileProgram_StubWithCallback(clCompileProgram_headers); + + // Compiling the program queries the program build log: + clGetProgramInfo_StubWithCallback(clGetProgramInfo_forBuildLog); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + clReleaseProgram_ExpectAndReturn(header0, CL_SUCCESS); + clReleaseProgram_ExpectAndReturn(header1, CL_SUCCESS); + + std::vector inputHeaders; + inputHeaders.push_back(cl::Program(header0)); + inputHeaders.push_back(cl::Program(header1)); + + std::vector headerIncludeNames; + headerIncludeNames.push_back("name0"); + headerIncludeNames.push_back("name1"); + + cl::Program prog(program); + cl_int errcode = prog.compile("", inputHeaders, headerIncludeNames); + + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + // Clean up in a defined order + prog = nullptr; + inputHeaders[0] = nullptr; + inputHeaders[1] = nullptr; +#endif +} + +static cl_int clCompileProgram_devices( + cl_program program, + cl_uint num_devices, + const cl_device_id * device_list, + const char * options, + cl_uint num_input_headers, + const cl_program * input_headers, + const char ** header_include_names, + void (CL_CALLBACK * pfn_notify)(cl_program program, + void * user_data), + void * user_data, + int num_calls) +{ + (void) num_calls; + + TEST_ASSERT_EQUAL(program, make_program(0)); + TEST_ASSERT_EQUAL(num_devices, 2); + TEST_ASSERT_NOT_EQUAL(device_list, nullptr); + TEST_ASSERT_EQUAL(device_list[0], make_device_id(0)); + TEST_ASSERT_EQUAL(device_list[1], make_device_id(1)); + TEST_ASSERT_EQUAL_STRING(options, ""); + TEST_ASSERT_EQUAL(num_input_headers, 0); + TEST_ASSERT_EQUAL(input_headers, nullptr); + TEST_ASSERT_EQUAL(header_include_names, nullptr); + TEST_ASSERT_EQUAL(pfn_notify, nullptr); + TEST_ASSERT_EQUAL(user_data, nullptr); + + return CL_SUCCESS; +} + +void testCompileProgramDevices(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_program program = make_program(0); + cl_device_id device0 = make_device_id(0); + cl_device_id device1 = make_device_id(1); + + clCompileProgram_StubWithCallback(clCompileProgram_devices); + + // Compiling the program queries the program build log: + clGetProgramInfo_StubWithCallback(clGetProgramInfo_forBuildLog); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetProgramBuildInfo_StubWithCallback(clGetProgramBuildInfo_testGetBuildInfo); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + + std::vector deviceList; + deviceList.push_back(cl::Device(device0)); + deviceList.push_back(cl::Device(device1)); + + cl::Program prog(program); + cl_int errcode = prog.compile("", deviceList); + + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + // Clean up in a defined order + prog = nullptr; + deviceList[0] = nullptr; + deviceList[1] = nullptr; +#endif +} + +/** +* Stub implementation of clGetCommandQueueInfo that returns first one image then none +*/ +static cl_int clGetSupportedImageFormats_testGetSupportedImageFormats( cl_context context, cl_mem_flags flags, - const cl_image_format *image_format, - const cl_image_desc *image_desc, - void *host_ptr, - cl_int *errcode_ret, + cl_mem_object_type image_type, + cl_uint num_entries, + cl_image_format *image_formats, + cl_uint *num_image_formats, int num_calls) { - TEST_ASSERT_EQUAL(0, num_calls); - TEST_ASSERT_EQUAL_PTR(make_context(0), context); - TEST_ASSERT_EQUAL_HEX(CL_MEM_READ_WRITE, flags); + (void) context; + (void) flags; + (void) image_type; + + // Catch failure case that causes error in bugzilla 13355: + // returns CL_INVALID_VALUE if flags or image_type are not valid, + // or if num_entries is 0 and image_formats is not nullptr. + if (num_entries == 0 && image_formats != nullptr) { + return CL_INVALID_VALUE; + } + if (num_entries == 0) { + // If num_entries was 0 this is the query for number + if (num_image_formats) { + if (num_calls == 0) { + *num_image_formats = 1; + } + else { + *num_image_formats = 0; + } + } + } + else { + // Should return something + TEST_ASSERT_NOT_NULL(image_formats); + + // For first call we should return one format here + if (num_calls == 1) { + TEST_ASSERT_EQUAL(num_entries, 1); + image_formats[0] = cl::ImageFormat(CL_RGB, CL_FLOAT); + } + } + + return CL_SUCCESS; +} + +void testGetSupportedImageFormats(void) +{ + cl_context ctx_cl = make_context(0); + + clGetSupportedImageFormats_StubWithCallback(clGetSupportedImageFormats_testGetSupportedImageFormats); + clGetSupportedImageFormats_StubWithCallback(clGetSupportedImageFormats_testGetSupportedImageFormats); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + + cl::Context ctx(ctx_cl); + std::vector formats; + cl_int ret = CL_SUCCESS; + + ret = ctx.getSupportedImageFormats( + CL_MEM_READ_WRITE, + CL_MEM_OBJECT_IMAGE2D, + &formats); + TEST_ASSERT_EQUAL(ret, CL_SUCCESS); + TEST_ASSERT_EQUAL(formats.size(), 1); + ret = ctx.getSupportedImageFormats( + CL_MEM_READ_WRITE, + CL_MEM_OBJECT_IMAGE2D, + &formats); + TEST_ASSERT_EQUAL(formats.size(), 0); + TEST_ASSERT_EQUAL(ret, CL_SUCCESS); +} + +void testCreateSubDevice(void) +{ + // TODO + +} + +void testGetContextInfoDevices(void) +{ + // TODO +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_mem clCreateImage_testCreateImage2DFromBuffer_2_0( + cl_context context, + cl_mem_flags flags, + const cl_image_format *image_format, + const cl_image_desc *image_desc, + void *host_ptr, + cl_int *errcode_ret, + int num_calls) +{ + (void) context; + (void) flags; + (void) num_calls; + + TEST_ASSERT_NOT_NULL(image_format); + TEST_ASSERT_NOT_NULL(image_desc); + TEST_ASSERT_NULL(host_ptr); + TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + + // Return the passed buffer as the cl_mem and success for the error code + if (errcode_ret) { + *errcode_ret = CL_SUCCESS; + } + return image_desc->buffer; +} +#endif + +void testCreateImage2DFromBuffer_2_0(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clGetContextInfo_StubWithCallback(clGetContextInfo_device); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clCreateImage_StubWithCallback(clCreateImage_testCreateImage2DFromBuffer_2_0); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + + cl_int err; + cl::Context context(make_context(0)); + + // Create buffer + // Create image from buffer + cl::Buffer buffer(make_mem(0)); + cl::Image2D imageFromBuffer( + context, + cl::ImageFormat(CL_R, CL_FLOAT), buffer, 64, 32, 256, &err); + + TEST_ASSERT_EQUAL_PTR(buffer(), imageFromBuffer()); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + + buffer() = nullptr; +#endif +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_mem clCreateImage_testCreateImage2D_2_0( + cl_context context, + cl_mem_flags flags, + const cl_image_format *image_format, + const cl_image_desc *image_desc, + void *host_ptr, + cl_int *errcode_ret, + int num_calls) +{ + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(make_context(0), context); + TEST_ASSERT_EQUAL_HEX(CL_MEM_READ_WRITE, flags); + + TEST_ASSERT_NOT_NULL(image_format); + TEST_ASSERT_EQUAL_HEX(CL_RGBA, image_format->image_channel_order); + TEST_ASSERT_EQUAL_HEX(CL_FLOAT, image_format->image_channel_data_type); + + TEST_ASSERT_NOT_NULL(image_desc); + TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + TEST_ASSERT_EQUAL(64, image_desc->image_width); + TEST_ASSERT_EQUAL(32, image_desc->image_height); + TEST_ASSERT_EQUAL(256, image_desc->image_row_pitch); + TEST_ASSERT_EQUAL(0, image_desc->num_mip_levels); + TEST_ASSERT_EQUAL(0, image_desc->num_samples); + TEST_ASSERT_NULL(image_desc->buffer); + + TEST_ASSERT_NULL(host_ptr); + + if (errcode_ret != nullptr) + *errcode_ret = CL_SUCCESS; + return make_mem(0); +} +#endif + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_mem clCreateImage_testCreateImage2DFromImage_2_0( + cl_context context, + cl_mem_flags flags, + const cl_image_format *image_format, + const cl_image_desc *image_desc, + void *host_ptr, + cl_int *errcode_ret, + int num_calls) +{ + (void) context; + (void) flags; + (void) num_calls; + + TEST_ASSERT_NOT_NULL(image_format); + TEST_ASSERT_NOT_NULL(image_desc); + TEST_ASSERT_NULL(host_ptr); + TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + + // Return the passed buffer as the cl_mem and success for the error code + if (errcode_ret) { + *errcode_ret = CL_SUCCESS; + } + return image_desc->buffer; +} +#endif + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_int clGetImageInfo_testCreateImage2DFromImage_2_0( + cl_mem image, + cl_image_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) image; + (void) param_name; + (void) param_value_size; + (void) param_value; + (void) param_value_size_ret; + + TEST_ASSERT_INT_WITHIN(6, 0, num_calls); + return CL_SUCCESS; +} +#endif + +void testCreateImage2DFromImage_2_0(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clGetContextInfo_StubWithCallback(clGetContextInfo_device); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clCreateImage_StubWithCallback(clCreateImage_testCreateImage2D_2_0); + + + cl_int err; + cl::Context context(make_context(0)); + + // As in 1.2 2D image test, needed as source for image-from-image + cl::Image2D image( + context, CL_MEM_READ_WRITE, + cl::ImageFormat(CL_RGBA, CL_FLOAT), 64, 32, 256, nullptr, &err); + + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); + + // Continue state for next phase + clGetImageInfo_StubWithCallback(clGetImageInfo_testCreateImage2DFromImage_2_0); + clCreateImage_StubWithCallback(clCreateImage_testCreateImage2DFromImage_2_0); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + + // Create 2D image from 2D Image with a new channel order + cl::Image2D imageFromImage( + context, + CL_sRGB, + image, + &err + ); + + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL_PTR(image(), imageFromImage()); + + //imageFromImage() = nullptr; + //image() = nullptr; + //context() = nullptr; +#endif +} + +// Note that default tests maintain state when run from the same +// unit process. +// One default setting test will maintain the defaults until the end. +void testSetDefaultPlatform(void) +{ + cl::Platform p(make_platform_id(1)); + cl::Platform p2 = cl::Platform::setDefault(p); + cl::Platform p3 = cl::Platform::getDefault(); + TEST_ASSERT_EQUAL(p(), p2()); + TEST_ASSERT_EQUAL(p(), p3()); +} + +// Note that default tests maintain state when run from the same +// unit process. +// One default setting test will maintain the defaults until the end. +void testSetDefaultPlatformTwice(void) +{ + cl::Platform p(make_platform_id(2)); + cl::Platform p2 = cl::Platform::getDefault(); + cl::Platform p3 = cl::Platform::setDefault(p); + // Set default should have failed + TEST_ASSERT_EQUAL(p2(), p3()); + TEST_ASSERT_NOT_EQUAL(p(), p3()); +} + +// Note that default tests maintain state when run from the same +// unit process. +// One default setting test will maintain the defaults until the end. +void testSetDefaultContext(void) +{ + + clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + + cl::Context c(make_context(1)); + cl::Context c2 = cl::Context::setDefault(c); + cl::Context c3 = cl::Context::getDefault(); + TEST_ASSERT_EQUAL(c(), c2()); + TEST_ASSERT_EQUAL(c(), c3()); +} + +// Note that default tests maintain state when run from the same +// unit process. +// One default setting test will maintain the defaults until the end. +void testSetDefaultCommandQueue(void) +{ + clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + + cl::CommandQueue c(make_command_queue(1)); + cl::CommandQueue c2 = cl::CommandQueue::setDefault(c); + cl::CommandQueue c3 = cl::CommandQueue::getDefault(); + TEST_ASSERT_EQUAL(c(), c2()); + TEST_ASSERT_EQUAL(c(), c3()); +} + +// Note that default tests maintain state when run from the same +// unit process. +// One default setting test will maintain the defaults until the end. +void testSetDefaultDevice(void) +{ + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + + clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + + cl::Device d(make_device_id(1)); + cl::Device d2 = cl::Device::setDefault(d); + cl::Device d3 = cl::Device::getDefault(); + TEST_ASSERT_EQUAL(d(), d2()); + TEST_ASSERT_EQUAL(d(), d3()); +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_command_queue clCreateCommandQueueWithProperties_testCommandQueueDevice( + cl_context context, + cl_device_id device, + const cl_queue_properties *properties, + cl_int *errcode_ret, + int num_calls) +{ + (void)num_calls; + TEST_ASSERT_EQUAL_PTR(make_context(1), context); + TEST_ASSERT_EQUAL_PTR(make_device_id(1), device); + TEST_ASSERT_EQUAL(properties[0], CL_QUEUE_PROPERTIES); + static cl_command_queue default_ = 0; + + if (errcode_ret != nullptr) + *errcode_ret = CL_SUCCESS; + + if ((properties[1] & CL_QUEUE_ON_DEVICE_DEFAULT) == 0) { + TEST_ASSERT_EQUAL(properties[1], (CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE)); + if (properties[2] == CL_QUEUE_SIZE) { + TEST_ASSERT_EQUAL(properties[3], 256); + TEST_ASSERT_EQUAL(properties[4], 0); + return make_command_queue(2); + } + else { + TEST_ASSERT_EQUAL(properties[2], 0); + return make_command_queue(3); + } + } + else { + TEST_ASSERT_EQUAL(properties[1], (CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT)); + if (default_ == 0) { + default_ = make_command_queue(4); + } + return default_; + } +} +#endif + +void testCreateDeviceCommandQueue(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clCreateCommandQueueWithProperties_StubWithCallback(clCreateCommandQueueWithProperties_testCommandQueueDevice); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(4), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(4), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(2), CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(3), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + + cl::Context c(make_context(1)); + cl::Context c2 = cl::Context::setDefault(c); + cl::Device d(make_device_id(1)); + + cl::DeviceCommandQueue dq(c, d); + cl::DeviceCommandQueue dq2(c, d, 256); + + cl::DeviceCommandQueue dqd = cl::DeviceCommandQueue::makeDefault(c, d); + cl::DeviceCommandQueue dqd2 = cl::DeviceCommandQueue::makeDefault(c, d); + + TEST_ASSERT_EQUAL(dqd(), dqd2()); +#endif +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_mem clCreatePipe_testCreatePipe( + cl_context context, + cl_mem_flags flags, + cl_uint packet_size, + cl_uint num_packets, + const cl_pipe_properties *props, + cl_int *errcode_ret, + int num_calls) +{ + (void) context; + (void) packet_size; + (void) num_packets; + (void) num_calls; + + if (flags == 0) { + flags = CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS; + } + TEST_ASSERT_EQUAL(flags, CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS); + TEST_ASSERT_NULL(props); + + if (errcode_ret) + *errcode_ret = CL_SUCCESS; + return make_mem(0); +} +#endif + +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 +static cl_int clGetPipeInfo_testCreatePipe( + cl_mem pipe, + cl_pipe_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) pipe; + (void) num_calls; + + TEST_ASSERT_NOT_NULL(param_value); + if (param_name == CL_PIPE_PACKET_SIZE) { + *static_cast(param_value) = 16; + if (param_value_size_ret) { + *param_value_size_ret = param_value_size; + } + return CL_SUCCESS; + } + else if (param_name == CL_PIPE_MAX_PACKETS) { + *static_cast(param_value) = 32; + if (param_value_size_ret) { + *param_value_size_ret = param_value_size; + } + return CL_SUCCESS; + } + else { + TEST_FAIL(); + return CL_INVALID_VALUE; + } +} +#endif + +void testCreatePipe(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + clCreatePipe_StubWithCallback(clCreatePipe_testCreatePipe); + clGetPipeInfo_StubWithCallback(clGetPipeInfo_testCreatePipe); + clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + + cl::Context c(make_context(1)); + cl::Pipe p(c, 16, 32); + cl::Pipe p2(16, 32); + + cl_uint size = p2.getInfo(); + cl_uint packets; + p2.getInfo(CL_PIPE_MAX_PACKETS, &packets); + + TEST_ASSERT_EQUAL(size, 16); + TEST_ASSERT_EQUAL(packets, 32); +#endif +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 +static cl_int clGetKernelSubGroupInfo_testSubGroups(cl_kernel kernel, + cl_device_id device, + cl_kernel_sub_group_info param_name, + size_t input_value_size, + const void *input_value, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) kernel; + (void) device; + (void) input_value_size; + (void) param_value_size; + (void) num_calls; + + TEST_ASSERT_NOT_NULL(input_value); + TEST_ASSERT_NOT_NULL(param_value); + + if (param_name == CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR) { + *static_cast(param_value) = 32; + if (param_value_size_ret) { + *param_value_size_ret = sizeof(size_t); + } + return CL_SUCCESS; + } + else if (param_name == CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR) { + *static_cast(param_value) = 2; + if (param_value_size_ret) { + *param_value_size_ret = sizeof(size_t); + } + return CL_SUCCESS; + } + else { + TEST_ABORT(); + } +} +#endif + +void testSubGroups(void) +{ +// TODO support testing cl_khr_subgroups on 2.0 +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clGetKernelSubGroupInfo_StubWithCallback(clGetKernelSubGroupInfo_testSubGroups); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseKernel_ExpectAndReturn(make_kernel(0), CL_SUCCESS); + + cl::Kernel k(make_kernel(0)); + cl::Device d(make_device_id(0)); + cl_int err; + cl::NDRange ndrange(8, 8); + size_t res1 = k.getSubGroupInfo( + d, ndrange, &err); + size_t res2 = 0; + err = k.getSubGroupInfo( + d, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, ndrange, &res2); + + TEST_ASSERT_EQUAL(res1, 32); + TEST_ASSERT_EQUAL(res2, 2); +#endif +} + +/** +* Stub implementation of clGetDeviceInfo that returns an absense of builtin kernels +*/ +static cl_int clGetDeviceInfo_builtin( + cl_device_id id, + cl_device_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) id; + (void) param_value_size; + + // Test to verify case where empty string is returned - so size is 0 + (void)num_calls; + TEST_ASSERT_EQUAL_HEX(CL_DEVICE_BUILT_IN_KERNELS, param_name); + if (param_value == nullptr) { + if (param_value_size_ret != nullptr) { + *param_value_size_ret = 0; + } + } + return CL_SUCCESS; +} + +void testBuiltInKernels(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + cl::Device d0(make_device_id(0)); + + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_builtin); + cl::string s = d0.getInfo(); +#endif +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 +/** + * Stub implementation of clCloneKernel that returns a new kernel object + */ +static cl_kernel clCloneKernel_simplecopy( + cl_kernel k, + cl_int *errcode_ret, + int num_calls) +{ + (void) k; + (void) num_calls; + + // Test to verify case where empty string is returned - so size is 0 + if (errcode_ret != nullptr) + *errcode_ret = CL_SUCCESS; + return make_kernel(POOL_MAX); +} +#endif + +void testCloneKernel(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 + clCloneKernel_StubWithCallback(clCloneKernel_simplecopy); + clReleaseKernel_ExpectAndReturn(make_kernel(POOL_MAX), CL_SUCCESS); + cl::Kernel clone = kernelPool[0].clone(); + TEST_ASSERT_EQUAL(clone(), make_kernel(POOL_MAX)); +#endif +} + +void testEnqueueMapSVM(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + std::vector vec(7); + clEnqueueSVMMap_ExpectAndReturn(commandQueuePool[0].get(), CL_TRUE, CL_MAP_READ|CL_MAP_WRITE, static_cast(vec.data()), vec.size()*sizeof(int), 0, nullptr, nullptr, CL_SUCCESS); + TEST_ASSERT_EQUAL(commandQueuePool[0].enqueueMapSVM(vec, CL_TRUE, CL_MAP_READ|CL_MAP_WRITE), CL_SUCCESS); +#endif +} + +void testMapSVM(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + std::vector vec(1); + clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clEnqueueSVMMap_ExpectAndReturn(make_command_queue(1), CL_TRUE, CL_MAP_READ|CL_MAP_WRITE, static_cast(vec.data()), vec.size()*sizeof(int), 0, nullptr, nullptr, CL_SUCCESS); + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + TEST_ASSERT_EQUAL(cl::mapSVM(vec), CL_SUCCESS); +#endif +} + +// Run after other tests to clear the default state in the header +// using special unit test bypasses. +// We cannot remove the once_flag, so this is a hard fix +// but it means we won't hit cmock release callbacks at the end. +// This is a lot like tearDown but for the header default +// so we do not want to run it for every test. +// The alternative would be to manually modify the test runner +// but we avoid that for now. +void testCleanupHeaderState(void) +{ + clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + + cl::CommandQueue::unitTestClearDefault(); + cl::Context::unitTestClearDefault(); + cl::Device::unitTestClearDefault(); + cl::Platform::unitTestClearDefault(); +} + +// OpenCL 2.2 APIs: + +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 +static void CL_CALLBACK test_program_release_callback( + cl_program, + void*) +{ +} +#endif + +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 +static cl_int clSetProgramReleaseCallback_set( + cl_program program, + void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), + void *user_data, + int num_calls) +{ + (void) user_data; + (void) num_calls; + + TEST_ASSERT_EQUAL_PTR(make_program(0), program); + TEST_ASSERT_EQUAL_PTR(pfn_notify, test_program_release_callback); + + return CL_SUCCESS; +} +#endif + +void testSetProgramReleaseCallback(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 + cl_program program = make_program(0); + int user_data = 0; + + clSetProgramReleaseCallback_StubWithCallback(clSetProgramReleaseCallback_set); + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + + prog.setReleaseCallback(test_program_release_callback, &user_data); +#endif +} + +void testSetProgramSpecializationConstantScalar(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 + cl_program program = make_program(0); + int sc = 0; + + clSetProgramSpecializationConstant_ExpectAndReturn(program, 0, sizeof(sc), &sc, CL_SUCCESS); + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + + prog.setSpecializationConstant(0, sc); +#endif +} + +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 +/// Stub for testing boolean specialization constants +static cl_int clSetProgramSpecializationConstant_testBool( + cl_program program, + cl_uint spec_id, + size_t spec_size, + const void* spec_value, + int num_calls) +{ + (void) num_calls; + + TEST_ASSERT_EQUAL_PTR(make_program(0), program); + TEST_ASSERT(spec_id == 0 || spec_id == 1); + TEST_ASSERT_EQUAL(spec_size, 1); + if (spec_id == 0) + { + const cl_uchar *uc_value = (const cl_uchar*)spec_value; + TEST_ASSERT_EQUAL_HEX(uc_value[0], 0); + } + if (spec_id == 1) + { + const cl_uchar *uc_value = (const cl_uchar*)spec_value; + TEST_ASSERT_EQUAL_HEX(uc_value[0], CL_UCHAR_MAX); + } + return CL_SUCCESS; +} +#endif + +void testSetProgramSpecializationConstantBool(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 + // Spec constant "false" should turn into a call with size one and no bits set. + // Spec constant "true" should turn into a call with size one and all bits set. + cl_program program = make_program(0); + bool scFalse = false; + bool scTrue = true; + + clSetProgramSpecializationConstant_StubWithCallback(clSetProgramSpecializationConstant_testBool); + + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + + prog.setSpecializationConstant(0, scFalse); + prog.setSpecializationConstant(1, scTrue); +#endif +} + +void testSetProgramSpecializationConstantPointer(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 220 + cl_program program = make_program(0); + int scArray[5] = {}; + + clSetProgramSpecializationConstant_ExpectAndReturn(program, 0, sizeof(scArray), &scArray, CL_SUCCESS); + clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + + cl::Program prog(program); + + prog.setSpecializationConstant(0, sizeof(scArray), scArray); +#endif +} + +// OpenCL 3.0 and cl_khr_extended_versioning Queries + +// Assumes the core enums, structures, and macros exactly match +// the extension enums, structures, and macros: + +static_assert(CL_PLATFORM_NUMERIC_VERSION == CL_PLATFORM_NUMERIC_VERSION_KHR, + "CL_PLATFORM_NUMERIC_VERSION mismatch"); +static_assert(CL_PLATFORM_EXTENSIONS_WITH_VERSION == CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, + "CL_PLATFORM_EXTENSIONS_WITH_VERSION mismatch"); + +static_assert(CL_DEVICE_NUMERIC_VERSION == CL_DEVICE_NUMERIC_VERSION_KHR, + "CL_DEVICE_NUMERIC_VERSION mismatch"); +static_assert(CL_DEVICE_EXTENSIONS_WITH_VERSION == CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, + "CL_DEVICE_EXTENSIONS_WITH_VERSION mismatch"); +static_assert(CL_DEVICE_ILS_WITH_VERSION == CL_DEVICE_ILS_WITH_VERSION_KHR, + "CL_DEVICE_ILS_WITH_VERSION mismatch"); +static_assert(CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION == CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, + "CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION mismatch"); + +static_assert(sizeof(cl_name_version) == sizeof(cl_name_version_khr), + "cl_name_version mismatch"); + +static_assert(CL_MAKE_VERSION(1, 2, 3) == CL_MAKE_VERSION_KHR(1, 2, 3), + "CL_MAKE_VERSION mismatch"); + +static cl_int clGetPlatformInfo_extended_versioning( + cl_platform_id id, + cl_platform_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) id; + (void) num_calls; + + switch (param_name) { + case CL_PLATFORM_NUMERIC_VERSION: + { + if (param_value_size == sizeof(cl_version) && param_value) { + *static_cast(param_value) = CL_MAKE_VERSION(1, 2, 3); + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_version); + } + return CL_SUCCESS; + } + case CL_PLATFORM_EXTENSIONS_WITH_VERSION: + { + static cl_name_version extension = { + CL_MAKE_VERSION(10, 11, 12), + "cl_dummy_extension", + }; + if (param_value_size == sizeof(cl_name_version) && param_value) { + *static_cast(param_value) = extension; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(extension); + } + return CL_SUCCESS; + } + default: break; + } + TEST_FAIL(); + return CL_INVALID_OPERATION; +} + +void testPlatformExtendedVersioning_3_0(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + cl::Platform p(make_platform_id(1)); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_extended_versioning); + + cl_version platformVersion = p.getInfo(); + TEST_ASSERT_EQUAL_HEX(platformVersion, CL_MAKE_VERSION(1, 2, 3)); + + std::vector extensions = p.getInfo(); + TEST_ASSERT_EQUAL(extensions.size(), 1); + TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION(10, 11, 12)); + TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 +} + +void testPlatformExtendedVersioning_KHR(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION < 300 + cl::Platform p(make_platform_id(1)); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_extended_versioning); + + cl_version_khr platformVersion = p.getInfo(); + TEST_ASSERT_EQUAL_HEX(platformVersion, CL_MAKE_VERSION_KHR(1, 2, 3)); + + std::vector extensions = p.getInfo(); + TEST_ASSERT_EQUAL(extensions.size(), 1); + TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION_KHR(10, 11, 12)); + TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); +#endif // CL_HPP_TARGET_OPENCL_VERSION < 300 +} + + +// Note: This assumes the core enums, structures, and macros exactly match +// the extension enums, structures, and macros. + +static cl_int clGetDeviceInfo_extended_versioning( + cl_device_id id, + cl_device_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) id; + (void) num_calls; + + switch (param_name) { + case CL_DEVICE_NUMERIC_VERSION: + { + if (param_value_size == sizeof(cl_version) && param_value) { + *static_cast(param_value) = CL_MAKE_VERSION(1, 2, 3); + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_version); + } + return CL_SUCCESS; + } + case CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR: + { + if (param_value_size == sizeof(cl_version_khr) && param_value) { + *static_cast(param_value) = CL_MAKE_VERSION_KHR(4, 5, 6); + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_version_khr); + } + return CL_SUCCESS; + } + case CL_DEVICE_EXTENSIONS_WITH_VERSION: + { + static cl_name_version extension = { + CL_MAKE_VERSION(10, 11, 12), + "cl_dummy_extension", + }; + if (param_value_size == sizeof(cl_name_version) && param_value) { + *static_cast(param_value) = extension; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(extension); + } + return CL_SUCCESS; + } + case CL_DEVICE_ILS_WITH_VERSION: + { + static cl_name_version il = { + CL_MAKE_VERSION(20, 21, 22), + "DUMMY_IR", + }; + if (param_value_size == sizeof(cl_name_version) && param_value) { + *static_cast(param_value) = il; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(il); + } + return CL_SUCCESS; + } + case CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION: + { + // Test no built-in kernels: + if (param_value_size_ret) { + *param_value_size_ret = 0; + } + return CL_SUCCESS; + } + case CL_DEVICE_OPENCL_C_ALL_VERSIONS: + { + static cl_name_version opencl_c = { + CL_MAKE_VERSION(30, 31, 32), + "OpenCL C", + }; + if (param_value_size == sizeof(cl_name_version) && param_value) { + *static_cast(param_value) = opencl_c; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(opencl_c); + } + return CL_SUCCESS; + } + case CL_DEVICE_OPENCL_C_FEATURES: + { + static cl_name_version opencl_c_features[] = { + { + CL_MAKE_VERSION(40, 41, 42), + "__opencl_c_feature", + }, + { + CL_MAKE_VERSION(40, 43, 44), + "__opencl_c_fancy_feature", + }, + }; + if (param_value_size == sizeof(opencl_c_features) && param_value) { + cl_name_version* feature = static_cast(param_value); + const int numFeatures = ARRAY_SIZE(opencl_c_features); + for (int i = 0; i < numFeatures; i++) { + feature[i] = opencl_c_features[i]; + } + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(opencl_c_features); + } + return CL_SUCCESS; + } + default: break; + } + TEST_FAIL(); + return CL_INVALID_OPERATION; +} + +void testDeviceExtendedVersioning_3_0(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_3_0); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + cl::Device d0(make_device_id(0)); + + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_extended_versioning); + + cl_version deviceVersion = d0.getInfo(); + TEST_ASSERT_EQUAL_HEX(deviceVersion, CL_MAKE_VERSION(1, 2, 3)); + + std::vector extensions = d0.getInfo(); + TEST_ASSERT_EQUAL(extensions.size(), 1); + TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION(10, 11, 12)); + TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); + + std::vector ils = d0.getInfo(); + TEST_ASSERT_EQUAL(ils.size(), 1); + TEST_ASSERT_EQUAL_HEX(ils[0].version, CL_MAKE_VERSION(20, 21, 22)); + TEST_ASSERT_EQUAL_STRING(ils[0].name, "DUMMY_IR"); + + std::vector opencl_c = d0.getInfo(); + TEST_ASSERT_EQUAL(opencl_c.size(), 1); + TEST_ASSERT_EQUAL_HEX(opencl_c[0].version, CL_MAKE_VERSION(30, 31, 32)); + TEST_ASSERT_EQUAL_STRING(opencl_c[0].name, "OpenCL C"); + + std::vector opencl_c_features = d0.getInfo(); + TEST_ASSERT_EQUAL(opencl_c_features.size(), 2); + TEST_ASSERT_EQUAL_HEX(opencl_c_features[0].version, CL_MAKE_VERSION(40, 41, 42)); + TEST_ASSERT_EQUAL_STRING(opencl_c_features[0].name, "__opencl_c_feature"); + TEST_ASSERT_EQUAL_HEX(opencl_c_features[1].version, CL_MAKE_VERSION(40, 43, 44)); + TEST_ASSERT_EQUAL_STRING(opencl_c_features[1].name, "__opencl_c_fancy_feature"); + + std::vector builtInKernels = d0.getInfo(); + TEST_ASSERT_EQUAL(builtInKernels.size(), 0); +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 +} + +void testDeviceExtendedVersioning_KHR(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION < 300 + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + cl::Device d0(make_device_id(0)); + + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_extended_versioning); + + cl_version_khr deviceVersion = d0.getInfo(); + TEST_ASSERT_EQUAL_HEX(deviceVersion, CL_MAKE_VERSION_KHR(1, 2, 3)); + + cl_version_khr cVersion = d0.getInfo(); + TEST_ASSERT_EQUAL_HEX(cVersion, CL_MAKE_VERSION_KHR(4, 5, 6)); + + std::vector extensions = d0.getInfo(); + TEST_ASSERT_EQUAL(extensions.size(), 1); + TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION_KHR(10, 11, 12)); + TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); + + std::vector ils = d0.getInfo(); + TEST_ASSERT_EQUAL(ils.size(), 1); + TEST_ASSERT_EQUAL_HEX(ils[0].version, CL_MAKE_VERSION_KHR(20, 21, 22)); + TEST_ASSERT_EQUAL_STRING(ils[0].name, "DUMMY_IR"); + + std::vector builtInKernels = d0.getInfo(); + TEST_ASSERT_EQUAL(builtInKernels.size(), 0); +#endif // CL_HPP_TARGET_OPENCL_VERSION < 300 +} + +static cl_int clGetDeviceInfo_uuid_pci_bus_info( + cl_device_id id, + cl_device_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int num_calls) +{ + (void) id; + (void) num_calls; + + switch (param_name) { +#if defined(cl_khr_device_uuid) + case CL_DEVICE_UUID_KHR: + case CL_DRIVER_UUID_KHR: + { + if (param_value_size == CL_UUID_SIZE_KHR && param_value) { + cl_uchar* pUUID = static_cast(param_value); + cl_uchar start = + (param_name == CL_DEVICE_UUID_KHR) ? 1 : + (param_name == CL_DRIVER_UUID_KHR) ? 2 : + 0; + for (cl_uchar i = 0; i < CL_UUID_SIZE_KHR; i++) { + pUUID[i] = i + start; + } + } + if (param_value_size_ret) { + *param_value_size_ret = CL_UUID_SIZE_KHR; + } + return CL_SUCCESS; + } + case CL_DEVICE_LUID_VALID_KHR: + { + if (param_value_size == sizeof(cl_bool) && param_value) { + *static_cast(param_value) = CL_TRUE; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_bool); + } + return CL_SUCCESS; + } + case CL_DEVICE_LUID_KHR: + { + if (param_value_size == CL_LUID_SIZE_KHR && param_value) { + cl_uchar* pLUID = static_cast(param_value); + cl_uchar start = 3; + for (cl_uchar i = 0; i < CL_LUID_SIZE_KHR; i++) { + pLUID[i] = i + start; + } + } + if (param_value_size_ret) { + *param_value_size_ret = CL_LUID_SIZE_KHR; + } + return CL_SUCCESS; + } + case CL_DEVICE_NODE_MASK_KHR: + { + if (param_value_size == sizeof(cl_uint) && param_value) { + *static_cast(param_value) = 0xA5A5; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_uint); + } + return CL_SUCCESS; + } +#endif +#if defined(cl_khr_pci_bus_info) + case CL_DEVICE_PCI_BUS_INFO_KHR: + { + if (param_value_size == sizeof(cl_device_pci_bus_info_khr) && param_value) { + cl_device_pci_bus_info_khr* pInfo = static_cast(param_value); + pInfo->pci_domain = 0x11; + pInfo->pci_bus = 0x22; + pInfo->pci_device = 0x33; + pInfo->pci_function = 0x44; + } + if (param_value_size_ret) { + *param_value_size_ret = sizeof(cl_device_pci_bus_info_khr); + } + return CL_SUCCESS; + } +#endif + default: break; + } + TEST_FAIL(); + return CL_INVALID_OPERATION; +} + +void testDeviceUUID_KHR(void) +{ +#if defined(cl_khr_device_uuid) + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + cl::Device d0(make_device_id(0)); + + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_uuid_pci_bus_info); + + std::array dev_uuid = d0.getInfo(); + for (int i = 0; i < CL_UUID_SIZE_KHR; i++) { + TEST_ASSERT_EQUAL_UINT8(i + 1, dev_uuid[i]); + } + std::array drv_uuid = d0.getInfo(); + for (int i = 0; i < CL_UUID_SIZE_KHR; i++) { + TEST_ASSERT_EQUAL_UINT8(i + 2, drv_uuid[i]); + } + + cl_bool valid = d0.getInfo(); + TEST_ASSERT_EQUAL(CL_TRUE, valid); + std::array luid = d0.getInfo(); + for (int i = 0; i < CL_LUID_SIZE_KHR; i++) { + TEST_ASSERT_EQUAL_UINT8(i + 3, luid[i]); + } + + cl_uint nodeMask = d0.getInfo(); + TEST_ASSERT_EQUAL(0xA5A5, nodeMask); +#endif +} + +void testDevicePCIBusInfo_KHR(void) +{ +#if defined(cl_khr_pci_bus_info) + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + + cl::Device d0(make_device_id(0)); + + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_uuid_pci_bus_info); + + cl_device_pci_bus_info_khr info = d0.getInfo(); + TEST_ASSERT_EQUAL_HEX(0x11, info.pci_domain); + TEST_ASSERT_EQUAL_HEX(0x22, info.pci_bus); + TEST_ASSERT_EQUAL_HEX(0x33, info.pci_device); + TEST_ASSERT_EQUAL_HEX(0x44, info.pci_function); +#endif +} + +static cl_int clGetProgramInfo_testProgramGetContext(cl_program program, + cl_program_build_info param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL_PTR(make_program(0), program); + TEST_ASSERT_EQUAL_HEX(CL_PROGRAM_CONTEXT, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_context)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_context); + if (param_value != nullptr) + *static_cast(param_value) = make_context(0); + return CL_SUCCESS; +} + +static cl_program clLinkProgram_testLinkProgram(cl_context context, + cl_uint num_devices, + const cl_device_id * device_list, + const char * options, + cl_uint num_input_programs, + const cl_program * input_programs, + void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), + void * user_data, + cl_int * errcode_ret, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL_PTR(context, make_context(0)); + TEST_ASSERT_EQUAL(num_devices, 0); + TEST_ASSERT_EQUAL(device_list, nullptr); + if (options) { + TEST_ASSERT_EQUAL_STRING(options, "-cl-program-link-options"); + } + TEST_ASSERT_NOT_EQUAL(num_input_programs, 0); + for (int i=0; i<(int)num_input_programs; i++) + TEST_ASSERT_EQUAL_PTR(input_programs[i], make_program(i)); + TEST_ASSERT_EQUAL(pfn_notify, nullptr); + TEST_ASSERT_EQUAL(user_data, nullptr); + + *errcode_ret = CL_SUCCESS; + return make_program(0); +} + +void testLinkProgram(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_int errcode; + int refcount[] = {1,1}; + + // verify if class cl::Program was not modified + TEST_ASSERT_EQUAL(sizeof(cl_program), sizeof(cl::Program)); + + clGetProgramInfo_StubWithCallback(clGetProgramInfo_testProgramGetContext); + clLinkProgram_StubWithCallback(clLinkProgram_testLinkProgram); + + clRetainContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + prepare_programRefcounts(2, reinterpret_cast(programPool), refcount); + + cl::Program prog = cl::linkProgram(cl::Program(make_program(0)), cl::Program(make_program(1)), + nullptr, nullptr, nullptr, &errcode); + + TEST_ASSERT_EQUAL_PTR(prog(), make_program(0)); + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + prog() = nullptr; +#endif +} + +void testLinkProgramWithOptions(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_int errcode; + int refcount[] = {1,1}; + + // verify if class cl::Program was not modified + TEST_ASSERT_EQUAL(sizeof(cl_program), sizeof(cl::Program)); + + clGetProgramInfo_StubWithCallback(clGetProgramInfo_testProgramGetContext); + clLinkProgram_StubWithCallback(clLinkProgram_testLinkProgram); + + clRetainContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + prepare_programRefcounts(2, reinterpret_cast(programPool), refcount); + + cl::Program prog = cl::linkProgram( + cl::Program(make_program(0)), cl::Program(make_program(1)), + "-cl-program-link-options", nullptr, nullptr, &errcode); + + TEST_ASSERT_EQUAL_PTR(prog(), make_program(0)); + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + prog() = nullptr; +#endif +} + +void testLinkProgramWithStringOptions(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_int errcode; + int refcount[] = {1,1}; + + // verify if class cl::Program was not modified + TEST_ASSERT_EQUAL(sizeof(cl_program), sizeof(cl::Program)); + + clGetProgramInfo_StubWithCallback(clGetProgramInfo_testProgramGetContext); + clLinkProgram_StubWithCallback(clLinkProgram_testLinkProgram); + + clRetainContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + prepare_programRefcounts(2, reinterpret_cast(programPool), refcount); + + cl::string options("-cl-program-link-options"); + cl::Program prog = cl::linkProgram( + cl::Program(make_program(0)), cl::Program(make_program(1)), + options, nullptr, nullptr, &errcode); + + TEST_ASSERT_EQUAL_PTR(prog(), make_program(0)); + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + prog() = nullptr; +#endif +} + +void testLinkProgramWithVectorProgramInput(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 120 + cl_int errcode; + VECTOR_CLASS prog_vec; + std::array refcount; + for (int i=0;i<(int)ARRAY_SIZE(programPool);i++) { + prog_vec.push_back(cl::Program(programPool[i]())); + refcount[i] = 1; + } + + // verify if class cl::Program was not modified + TEST_ASSERT_EQUAL(sizeof(cl_program), sizeof(cl::Program)); + + clGetProgramInfo_StubWithCallback(clGetProgramInfo_testProgramGetContext); + clLinkProgram_StubWithCallback(clLinkProgram_testLinkProgram); + prepare_programRefcounts(prog_vec.size(), reinterpret_cast(prog_vec.data()), refcount.data()); + + clRetainContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); + + cl::Program prog = linkProgram(prog_vec, nullptr, nullptr, nullptr, &errcode); + + TEST_ASSERT_EQUAL_PTR(prog(), make_program(0)); + TEST_ASSERT_EQUAL(errcode, CL_SUCCESS); + + prog() = nullptr; +#endif +} + +void testGetPlatformVersion_1_1(void) +{ + cl_platform_id platform = make_platform_id(0); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); + + cl_uint version = cl::detail::getPlatformVersion(platform); + TEST_ASSERT_EQUAL_UINT32(0x10001, version); +} + +void testGetPlatformVersion_1_2(void) +{ + cl_platform_id platform = make_platform_id(0); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_2); + + cl_uint version = cl::detail::getPlatformVersion(platform); + TEST_ASSERT_EQUAL_UINT32(0x10002, version); +} + +void testGetPlatformVersion_2_0(void) +{ + cl_platform_id platform = make_platform_id(0); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + + cl_uint version = cl::detail::getPlatformVersion(platform); + TEST_ASSERT_EQUAL_UINT32(0x20000, version); +} + + +void testGetPlatformVersion_3_0(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 300 + cl_platform_id platform = make_platform_id(0); + + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_3_0); + + cl_uint version = cl::detail::getPlatformVersion(platform); + TEST_ASSERT_EQUAL_UINT32(0x30000, version); +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 +} + +/**************************************************************************** + * Tests for cl::CommandBufferKhr + ****************************************************************************/ +#if defined(cl_khr_command_buffer) +void testMoveAssignCommandBufferKhrNonNull(void); +void testMoveAssignCommandBufferKhrNull(void); +void testMoveConstructCommandBufferKhrNonNull(void); +void testMoveConstructCommandBufferKhrNull(void); +MAKE_MOVE_TESTS(CommandBufferKhr, make_command_buffer_khr, clReleaseCommandBufferKHR, commandBufferKhrPool) +#else +void testMoveAssignCommandBufferKhrNonNull(void) {} +void testMoveAssignCommandBufferKhrNull(void) {} +void testMoveConstructCommandBufferKhrNonNull(void) {} +void testMoveConstructCommandBufferKhrNull(void) {} +#endif + +// Stub for clGetCommandBufferInfoKHR that returns 1 +static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues( + cl_command_buffer_khr command_buffer, + cl_command_buffer_info_khr param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer); + TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_NUM_QUEUES_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_uint); + if (param_value != nullptr) + *static_cast (param_value) = 1; + return CL_SUCCESS; +} + +void testCommandBufferInfoKHRNumQueues(void) +{ +#if defined(cl_khr_command_buffer) + cl_uint expected = 1; + + clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetNumQueues); + + cl_uint num = commandBufferKhrPool[0].getInfo(); + TEST_ASSERT_EQUAL_HEX(expected, num); +#endif +} + +// Stub for clGetCommandBufferInfoKHR that returns command queues array +static cl_int clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues( + cl_command_buffer_khr command_buffer, + cl_command_buffer_info_khr param_name, + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL_PTR(make_command_buffer_khr(0), command_buffer); + TEST_ASSERT_EQUAL_HEX(CL_COMMAND_BUFFER_QUEUES_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl_command_queue)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = 3 * sizeof(cl_command_queue); + if (param_value != nullptr) + { + cl_command_queue *command_queues = static_cast (param_value); + command_queues[0] = make_command_queue(0); + command_queues[1] = make_command_queue(1); + command_queues[2] = make_command_queue(2); + } + return CL_SUCCESS; +} + +void testCommandBufferInfoKHRCommandQueues(void) +{ +#if defined(cl_khr_command_buffer) + // creat expected values for refcounter + VECTOR_CLASS expected_queue_vec; + std::array refcount; + for (int i=0;i<3;i++) { + expected_queue_vec.push_back(commandQueuePool[i]()); + refcount[i] = 1; + } + + clGetCommandBufferInfoKHR_StubWithCallback(clGetCommandBufferInfoKHR_testCommandBufferKhrGetCommandQueues); + prepare_commandQueueRefcounts(expected_queue_vec.size(), expected_queue_vec.data(), refcount.data()); + + VECTOR_CLASS command_queues = commandBufferKhrPool[0].getInfo(); + TEST_ASSERT_EQUAL(3, command_queues.size()); + TEST_ASSERT_EQUAL_PTR(make_command_queue(0), command_queues[0]()); + TEST_ASSERT_EQUAL_PTR(make_command_queue(1), command_queues[1]()); + TEST_ASSERT_EQUAL_PTR(make_command_queue(2), command_queues[2]()); +#endif +} + +/**************************************************************************** + * Tests for cl::MutableCommand + ****************************************************************************/ + +#if defined(cl_khr_command_buffer_mutable_dispatch) +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION < \ + CL_MAKE_VERSION(0, 9, 2) +static cl_int clUpdateMutableCommandsKHR_testCommandBufferKhrUpdateMutableCommands( + cl_command_buffer_khr command_buffer, + const cl_mutable_base_config_khr *mutable_config, int num_calls) { + (void)num_calls; + TEST_ASSERT_EQUAL(command_buffer, commandBufferKhrPool[0]()); + TEST_ASSERT_EQUAL(mutable_config->type, + CL_STRUCTURE_TYPE_MUTABLE_BASE_CONFIG_KHR); + return CL_SUCCESS; +} +#else +static cl_int clUpdateMutableCommandsKHR_testCommandBufferKhrUpdateMutableCommands( + cl_command_buffer_khr command_buffer, + unsigned int length, const cl_command_buffer_update_type_khr* types, const void** configs, + int num_calls) { + (void)num_calls; + TEST_ASSERT_EQUAL(command_buffer, commandBufferKhrPool[0]()); + TEST_ASSERT_EQUAL(length, 1u); + TEST_ASSERT_EQUAL(types[0], CL_STRUCTURE_TYPE_MUTABLE_DISPATCH_CONFIG_KHR); + + const void* config = configs[0]; + cl_mutable_dispatch_config_khr casted_config = *static_cast(config); + cl_mutable_dispatch_config_khr default_config{}; + + TEST_ASSERT_EQUAL(std::memcmp(&casted_config, &default_config, sizeof(cl_mutable_dispatch_config_khr)), 0); + return CL_SUCCESS; +} +#endif + +void testCommandBufferKhrUpdateMutableCommands(void) { + cl_int response = CL_INVALID_OPERATION; + cl_mutable_dispatch_config_khr dispatch_list{}; +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION < \ + CL_MAKE_VERSION(0, 9, 2) + cl_mutable_base_config_khr config = { + CL_STRUCTURE_TYPE_MUTABLE_BASE_CONFIG_KHR, &config, 1, &dispatch_list}; + clUpdateMutableCommandsKHR_StubWithCallback( + clUpdateMutableCommandsKHR_testCommandBufferKhrUpdateMutableCommands); + response = commandBufferKhrPool[0].updateMutableCommands(&config); +#else + constexpr cl_uint num_configs = 1; + std::array config_types = {{ + CL_STRUCTURE_TYPE_MUTABLE_DISPATCH_CONFIG_KHR + }}; + std::array configs = {&dispatch_list}; + clUpdateMutableCommandsKHR_StubWithCallback( + clUpdateMutableCommandsKHR_testCommandBufferKhrUpdateMutableCommands); + response = commandBufferKhrPool[0].updateMutableCommands(config_types, configs); +#endif + TEST_ASSERT_EQUAL(CL_SUCCESS, response); +} + +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandQueue( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* /*param_value_size_ret*/, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_COMMAND_COMMAND_QUEUE_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_command_queue)); + if (param_value != nullptr) + { + *static_cast(param_value) = make_command_queue(0); + } + + return CL_SUCCESS; +} + +void testMutableCommandKhrGetInfoCommandQueue(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; + + int cmd_que_refcount = 1; + + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandQueue); + prepare_commandQueueRefcounts(1, reinterpret_cast(&commandQueuePool[0]()), &cmd_que_refcount); + + cl::CommandQueue command_queue = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(commandQueuePool[0](), command_queue()); +} + +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandBuffer( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* /*param_value_size_ret*/, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_COMMAND_COMMAND_BUFFER_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_command_buffer_khr)); + if (param_value != nullptr) + { + *static_cast(param_value) = make_command_buffer_khr(0); + } + + return CL_SUCCESS; +} - TEST_ASSERT_NOT_NULL(image_format); - TEST_ASSERT_EQUAL_HEX(CL_RGBA, image_format->image_channel_order); - TEST_ASSERT_EQUAL_HEX(CL_FLOAT, image_format->image_channel_data_type); +void testMutableCommandKhrGetInfoCommandBuffer(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; - TEST_ASSERT_NOT_NULL(image_desc); - TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); - TEST_ASSERT_EQUAL(64, image_desc->image_width); - TEST_ASSERT_EQUAL(32, image_desc->image_height); - TEST_ASSERT_EQUAL(256, image_desc->image_row_pitch); - TEST_ASSERT_EQUAL(0, image_desc->num_mip_levels); - TEST_ASSERT_EQUAL(0, image_desc->num_samples); - TEST_ASSERT_NULL(image_desc->buffer); + int cmd_bhr_khr_refcount = 1; - TEST_ASSERT_NULL(host_ptr); + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandBuffer); + prepare_commandBufferKhrRefcounts(1, reinterpret_cast(&commandBufferKhrPool[0]()), &cmd_bhr_khr_refcount); - if (errcode_ret != NULL) - *errcode_ret = CL_SUCCESS; - return make_mem(0); + cl::CommandBufferKhr command_buffer_khr = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(commandBufferKhrPool[0](), command_buffer_khr()); } -static cl_mem clCreateImage_testCreateImage2DFromImage_2_0( - cl_context context, - cl_mem_flags flags, - const cl_image_format *image_format, - const cl_image_desc *image_desc, - void *host_ptr, - cl_int *errcode_ret, +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoPropertiesArray( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* param_value_size_ret, int num_calls) { - TEST_ASSERT_NOT_NULL(image_format); - TEST_ASSERT_NOT_NULL(image_desc); - TEST_ASSERT_NULL(host_ptr); - TEST_ASSERT_EQUAL_HEX(CL_MEM_OBJECT_IMAGE2D, image_desc->image_type); + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); - // Return the passed buffer as the cl_mem and success for the error code - if (errcode_ret) { - *errcode_ret = CL_SUCCESS; +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION < \ + CL_MAKE_VERSION(0, 9, 2) + using properties_type = cl_ndrange_kernel_command_properties_khr; + cl_mutable_command_info_khr properties_query = CL_MUTABLE_DISPATCH_PROPERTIES_ARRAY_KHR; +#else + using properties_type = cl_command_properties_khr; + cl_mutable_command_info_khr properties_query = CL_MUTABLE_COMMAND_PROPERTIES_ARRAY_KHR; +#endif + switch (num_calls) + { + case 0: + + TEST_ASSERT_EQUAL(param_name, properties_query); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(properties_type)); + if (param_value_size_ret != nullptr) + { + *param_value_size_ret = 3 * sizeof(properties_type); + } + break; + case 1: + TEST_ASSERT_EQUAL(param_name, properties_query); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(properties_type)); + TEST_ASSERT_EQUAL(nullptr, param_value_size_ret); + if (param_value != nullptr) + { + properties_type properties[] = { 1, 2, 3 }; + for (int i = 0; i < 3; i++) + { + *(&static_cast(param_value)[i]) = properties[i]; + } + } + break; } - return image_desc->buffer; -} -static cl_int clGetImageInfo_testCreateImage2DFromImage_2_0( - cl_mem image, - cl_image_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, - int num_calls) -{ - TEST_ASSERT_INT_WITHIN(6, 0, num_calls); return CL_SUCCESS; } -void testCreateImage2DFromImage_2_0() +void testMutableCommandKhrGetInfoPropertiesArray(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - clGetContextInfo_StubWithCallback(clGetContextInfo_device); - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clCreateImage_StubWithCallback(clCreateImage_testCreateImage2D_2_0); + cl_int err = CL_DEVICE_NOT_FOUND; + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoPropertiesArray); +#if CL_KHR_COMMAND_BUFFER_MUTABLE_DISPATCH_EXTENSION_VERSION < \ + CL_MAKE_VERSION(0, 9, 2) + cl::vector kernel_properties = mutableCommandKhrPool[0].getInfo(&err); +#else + cl::vector kernel_properties = mutableCommandKhrPool[0].getInfo(&err); +#endif - cl_int err; - cl::Context context(make_context(0)); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(3, kernel_properties.size()); + for (size_t i = 0; i < kernel_properties.size(); i++) + { + TEST_ASSERT_EQUAL(i + 1, kernel_properties[i]); + } +} - // As in 1.2 2D image test, needed as source for image-from-image - cl::Image2D image( - context, CL_MEM_READ_WRITE, - cl::ImageFormat(CL_RGBA, CL_FLOAT), 64, 32, 256, NULL, &err); +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandType( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* /*param_value_size_ret*/, + int /*num_calls*/) +{ + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_COMMAND_COMMAND_TYPE_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_command_type)); + if (param_value != nullptr) + { + *static_cast(param_value) = 0xDEAD; + } - TEST_ASSERT_EQUAL(CL_SUCCESS, err); - TEST_ASSERT_EQUAL_PTR(make_mem(0), image()); + return CL_SUCCESS; +} - // Continue state for next phase - clGetImageInfo_StubWithCallback(clGetImageInfo_testCreateImage2DFromImage_2_0); - clCreateImage_StubWithCallback(clCreateImage_testCreateImage2DFromImage_2_0); - clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); - clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); +void testMutableCommandKhrGetInfoCommandType(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; - // Create 2D image from 2D Image with a new channel order - cl::Image2D imageFromImage( - context, - CL_sRGB, - image, - &err - ); + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoCommandType); + cl_command_type command_type = mutableCommandKhrPool[0].getInfo(&err); TEST_ASSERT_EQUAL(CL_SUCCESS, err); - TEST_ASSERT_EQUAL_PTR(image(), imageFromImage()); - - //imageFromImage() = NULL; - //image() = NULL; - //context() = NULL; -#endif + TEST_ASSERT_EQUAL(0xDEAD, command_type); } -// Note that default tests maintain state when run from the same -// unit process. -// One default setting test will maintain the defaults until the end. -void testSetDefaultPlatform() +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoDispatchKernel( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* /*param_value_size_ret*/, + int /*num_calls*/) { - cl::Platform p(make_platform_id(1)); - cl::Platform p2 = cl::Platform::setDefault(p); - cl::Platform p3 = cl::Platform::getDefault(); - TEST_ASSERT_EQUAL(p(), p2()); - TEST_ASSERT_EQUAL(p(), p3()); -} + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_KERNEL_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_kernel)); + if (param_value != nullptr) + { + *static_cast(param_value) = make_kernel(0); + } -// Note that default tests maintain state when run from the same -// unit process. -// One default setting test will maintain the defaults until the end. -void testSetDefaultPlatformTwice() -{ - cl::Platform p(make_platform_id(2)); - cl::Platform p2 = cl::Platform::getDefault(); - cl::Platform p3 = cl::Platform::setDefault(p); - // Set default should have failed - TEST_ASSERT_EQUAL(p2(), p3()); - TEST_ASSERT_NOT_EQUAL(p(), p3()); + return CL_SUCCESS; } -// Note that default tests maintain state when run from the same -// unit process. -// One default setting test will maintain the defaults until the end. -void testSetDefaultContext() -{ +void testMutableCommandKhrGetInfoDispatchKernel(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; - clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoDispatchKernel); - cl::Context c(make_context(1)); - cl::Context c2 = cl::Context::setDefault(c); - cl::Context c3 = cl::Context::getDefault(); - TEST_ASSERT_EQUAL(c(), c2()); - TEST_ASSERT_EQUAL(c(), c3()); + cl_kernel kernel = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(make_kernel(0), kernel); } -// Note that default tests maintain state when run from the same -// unit process. -// One default setting test will maintain the defaults until the end. -void testSetDefaultCommandQueue() +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoDispatchDimensions( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* /*param_value_size_ret*/, + int /*num_calls*/) { - clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_DIMENSIONS_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint)); + if (param_value != nullptr) + { + *static_cast(param_value) = 3; + } - cl::CommandQueue c(make_command_queue(1)); - cl::CommandQueue c2 = cl::CommandQueue::setDefault(c); - cl::CommandQueue c3 = cl::CommandQueue::getDefault(); - TEST_ASSERT_EQUAL(c(), c2()); - TEST_ASSERT_EQUAL(c(), c3()); + return CL_SUCCESS; } -// Note that default tests maintain state when run from the same -// unit process. -// One default setting test will maintain the defaults until the end. -void testSetDefaultDevice() +void testMutableCommandKhrGetInfoDispatchDimensions(void) { - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); + cl_int err = CL_DEVICE_NOT_FOUND; - clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clRetainDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoDispatchDimensions); - cl::Device d(make_device_id(1)); - cl::Device d2 = cl::Device::setDefault(d); - cl::Device d3 = cl::Device::getDefault(); - TEST_ASSERT_EQUAL(d(), d2()); - TEST_ASSERT_EQUAL(d(), d3()); + cl_uint dimensions = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(3, dimensions); } -static cl_command_queue clCreateCommandQueueWithProperties_testCommandQueueDevice( - cl_context context, - cl_device_id device, - const cl_queue_properties *properties, - cl_int *errcode_ret, +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoGlobalWorkOffset( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* param_value_size_ret, int num_calls) { - (void)num_calls; - TEST_ASSERT_EQUAL_PTR(make_context(1), context); - TEST_ASSERT_EQUAL_PTR(make_device_id(1), device); - TEST_ASSERT_EQUAL(properties[0], CL_QUEUE_PROPERTIES); - static cl_command_queue default_ = 0; - - if (errcode_ret != NULL) - *errcode_ret = CL_SUCCESS; - - if ((properties[1] & CL_QUEUE_ON_DEVICE_DEFAULT) == 0) { - TEST_ASSERT_EQUAL(properties[1], (CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE)); - if (properties[2] == CL_QUEUE_SIZE) { - TEST_ASSERT_EQUAL(properties[3], 256); - TEST_ASSERT_EQUAL(properties[4], 0); - return make_command_queue(2); - } - else { - TEST_ASSERT_EQUAL(properties[2], 0); - return make_command_queue(3); + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + switch (num_calls) + { + case 0: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_GLOBAL_WORK_OFFSET_KHR); + TEST_ASSERT_EQUAL(nullptr, param_value); + if (param_value_size_ret != nullptr) + { + *param_value_size_ret = 3 * sizeof(cl::size_type); } - } - else { - TEST_ASSERT_EQUAL(properties[1], (CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE | CL_QUEUE_ON_DEVICE | CL_QUEUE_ON_DEVICE_DEFAULT)); - if (default_ == 0) { - default_ = make_command_queue(4); + break; + case 1: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_GLOBAL_WORK_OFFSET_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl::size_type)); + TEST_ASSERT_EQUAL(nullptr, param_value_size_ret); + TEST_ASSERT_NOT_NULL(param_value); + if (param_value != nullptr) + { + cl::size_type data[] = { 2, 3, 4 }; + for (int i = 0; i < 3; i++) + { + *(&(static_cast(param_value)[i])) = data[i]; + } } - return default_; + break; } + + return CL_SUCCESS; } -void testCreateDeviceCommandQueue() +void testMutableCommandKhrGetInfoGlobalWorkOffset(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clCreateCommandQueueWithProperties_StubWithCallback(clCreateCommandQueueWithProperties_testCommandQueueDevice); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(4), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(4), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(2), CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(3), CL_SUCCESS); - clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - - cl::Context c(make_context(1)); - cl::Context c2 = cl::Context::setDefault(c); - cl::Device d(make_device_id(1)); - - cl::DeviceCommandQueue dq(c, d); - cl::DeviceCommandQueue dq2(c, d, 256); + cl_int err = CL_DEVICE_NOT_FOUND; - cl::DeviceCommandQueue dqd = cl::DeviceCommandQueue::makeDefault(c, d); - cl::DeviceCommandQueue dqd2 = cl::DeviceCommandQueue::makeDefault(c, d); + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoGlobalWorkOffset); - TEST_ASSERT_EQUAL(dqd(), dqd2()); -#endif + cl::vector global_work_offset = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(3, global_work_offset.size()); + for (cl::size_type i = 0; i < global_work_offset.size(); i++) + { + TEST_ASSERT_EQUAL(i + 2, global_work_offset[i]); + } } -static cl_mem clCreatePipe_testCreatePipe( - cl_context context, - cl_mem_flags flags, - cl_uint packet_size, - cl_uint num_packets, - const cl_pipe_properties *props, - cl_int *errcode_ret, +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoGlobalWorkSize( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* param_value_size_ret, int num_calls) { - if (flags == 0) { - flags = CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS; + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + switch (num_calls) + { + case 0: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_GLOBAL_WORK_SIZE_KHR); + TEST_ASSERT_EQUAL(nullptr, param_value); + if (param_value_size_ret != nullptr) + { + *param_value_size_ret = 3 * sizeof(cl::size_type); + } + break; + case 1: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_GLOBAL_WORK_SIZE_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl::size_type)); + TEST_ASSERT_EQUAL(nullptr, param_value_size_ret); + TEST_ASSERT_NOT_NULL(param_value); + if (param_value != nullptr) + { + cl::size_type data[] = { 3, 4, 5 }; + for (cl::size_type i = 0; i < 3; i++) + { + *(&(static_cast(param_value)[i])) = data[i]; + } + } + break; } - TEST_ASSERT_EQUAL(flags, CL_MEM_READ_WRITE | CL_MEM_HOST_NO_ACCESS); - TEST_ASSERT_NULL(props); - if (errcode_ret) - *errcode_ret = CL_SUCCESS; - return make_mem(0); + return CL_SUCCESS; } -static cl_int clGetPipeInfo_testCreatePipe( - cl_mem pipe, - cl_pipe_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, +void testMutableCommandKhrGetInfoGlobalWorkSize(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; + + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoGlobalWorkSize); + + cl::vector global_work_size = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(3, global_work_size.size()); + for (cl::size_type i = 0; i < global_work_size.size(); i++) + { + TEST_ASSERT_EQUAL(i + 3, global_work_size[i]); + } +} + +static cl_int clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoLocalWorkSize( + cl_mutable_command_khr command, cl_mutable_command_info_khr param_name, + size_t param_value_size, void* param_value, size_t* param_value_size_ret, int num_calls) { - TEST_ASSERT_NOT_NULL(param_value); - if (param_name == CL_PIPE_PACKET_SIZE) { - *static_cast(param_value) = 16; - if (param_value_size_ret) { - *param_value_size_ret = param_value_size; + TEST_ASSERT_EQUAL(command, mutableCommandKhrPool[0]()); + switch (num_calls) + { + case 0: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_LOCAL_WORK_SIZE_KHR); + TEST_ASSERT_EQUAL(nullptr, param_value); + if (param_value_size_ret != nullptr) + { + *param_value_size_ret = 3 * sizeof(cl::size_type); } - return CL_SUCCESS; - } - else if (param_name == CL_PIPE_MAX_PACKETS) { - *static_cast(param_value) = 32; - if (param_value_size_ret) { - *param_value_size_ret = param_value_size; + break; + case 1: + TEST_ASSERT_EQUAL(param_name, CL_MUTABLE_DISPATCH_LOCAL_WORK_SIZE_KHR); + TEST_ASSERT(param_value == nullptr || param_value_size >= 3 * sizeof(cl::size_type)); + TEST_ASSERT_EQUAL(nullptr, param_value_size_ret); + TEST_ASSERT_NOT_NULL(param_value); + if (param_value != nullptr) + { + cl::size_type data[] = { 4, 5, 6 }; + for (int i = 0; i < 3; i++) + { + *(&(static_cast(param_value)[i])) = data[i]; + } } - return CL_SUCCESS; + break; } - else { - TEST_FAIL(); - return CL_INVALID_VALUE; + + return CL_SUCCESS; +} + +void testMutableCommandKhrGetInfoLocalWorkSize(void) +{ + cl_int err = CL_DEVICE_NOT_FOUND; + + clGetMutableCommandInfoKHR_StubWithCallback(clGetMutableCommandInfoKHR_testMutableCommandKhrGetInfoLocalWorkSize); + + cl::vector local_work_size = mutableCommandKhrPool[0].getInfo(&err); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(3, local_work_size.size()); + for (cl::size_type i = 0; i < local_work_size.size(); i++) + { + TEST_ASSERT_EQUAL(i + 4, local_work_size[i]); } } +#endif -void testCreatePipe() -{ -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - clCreatePipe_StubWithCallback(clCreatePipe_testCreatePipe); - clGetPipeInfo_StubWithCallback(clGetPipeInfo_testCreatePipe); - clRetainContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); - clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); +// Tests for Device::GetInfo +static cl_int clGetInfo_testDeviceGetInfoCLDeviceVendorId( + cl_device_id device, cl_device_info param_name, size_t param_value_size, + void *param_value, size_t *param_value_size_ret, int cmock_num_calls) +{ + (void) cmock_num_calls; - cl::Context c(make_context(1)); - cl::Pipe p(c, 16, 32); - cl::Pipe p2(16, 32); + TEST_ASSERT_EQUAL_PTR(make_device_id(0), device); + TEST_ASSERT_EQUAL_HEX(CL_DEVICE_VENDOR_ID, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_uint); + if (param_value != nullptr) + { + *static_cast(param_value) = 0xABCD; + } + return CL_SUCCESS; +} +void testDevice_GetInfo_CLDeviceVendorID(void) +{ + cl_uint expected = 0xABCD; + clGetDeviceInfo_StubWithCallback( + clGetInfo_testDeviceGetInfoCLDeviceVendorId); + cl_uint vendorID = devicePool[0].getInfo(); + TEST_ASSERT_EQUAL_HEX(expected, vendorID); +} +static cl_int clGetInfo_testDeviceGetInfoCLDeviceImageSupport( + cl_device_id device, cl_device_info param_name, size_t param_value_size, + void *param_value, size_t *param_value_size_ret, int cmock_num_calls) +{ + (void) cmock_num_calls; - cl_uint size = p2.getInfo(); - cl_uint packets; - p2.getInfo(CL_PIPE_MAX_PACKETS, &packets); + TEST_ASSERT_EQUAL_PTR(make_device_id(0), device); + TEST_ASSERT_EQUAL_HEX(CL_DEVICE_IMAGE_SUPPORT, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_bool)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_bool); + if (param_value != nullptr) + { + *static_cast(param_value) = true; + } + return CL_SUCCESS; +} +void testDevice_GetInfo_CLDeviceImageSupport(void) +{ + cl_bool expected = true; + clGetDeviceInfo_StubWithCallback( + clGetInfo_testDeviceGetInfoCLDeviceImageSupport); + cl_bool deviceImageSupport = + devicePool[0].getInfo(); + TEST_ASSERT_EQUAL_HEX(expected, deviceImageSupport); +} +static cl_int clGetInfo_testDeviceGetInfoCLDeviceName( + cl_device_id device, cl_device_info param_name, size_t param_value_size, + void *param_value, size_t *param_value_size_ret, int cmock_num_calls) +{ + (void) cmock_num_calls; - TEST_ASSERT_EQUAL(size, 16); - TEST_ASSERT_EQUAL(packets, 32); -#endif + static char testDeviceName[] = "testDeviceName"; + TEST_ASSERT_EQUAL_PTR(make_device_id(0), device); + TEST_ASSERT_EQUAL_HEX(CL_DEVICE_NAME, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(testDeviceName)); + + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(testDeviceName); + if (param_value != nullptr) + { + strcpy((char*)param_value, testDeviceName); + } + return CL_SUCCESS; +} +void testDevice_GetInfo_CLDeviceName(void) +{ + cl::string expected = "testDeviceName"; + clGetDeviceInfo_StubWithCallback(clGetInfo_testDeviceGetInfoCLDeviceName); + cl::string deviceName = devicePool[0].getInfo(); + TEST_ASSERT_EQUAL_STRING(expected.c_str(), deviceName.c_str()); } -static cl_int clGetKernelSubGroupInfo_testSubGroups(cl_kernel kernel, - cl_device_id device, - cl_kernel_sub_group_info param_name, - size_t input_value_size, - const void *input_value, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, - int num_calls) -{ - TEST_ASSERT_NOT_NULL(input_value); - TEST_ASSERT_NOT_NULL(param_value); +#if defined(cl_ext_device_fission) +static cl_int clCreateSubDevicesEXT_testDevice_createSubDevices( + cl_device_id device_in, const cl_device_partition_property_ext *properties, + cl_uint num_entries, cl_device_id *out_devices, cl_uint *num_devices, int cmock_num_calls) +{ + (void)cmock_num_calls; - if (param_name == CL_KERNEL_MAX_SUB_GROUP_SIZE_FOR_NDRANGE_KHR) { - *static_cast(param_value) = 32; - if (param_value_size_ret) { - *param_value_size_ret = sizeof(size_t); - } - return CL_SUCCESS; + TEST_ASSERT_EQUAL(CL_DEVICE_PARTITION_EQUALLY_EXT, *properties); + if (nullptr != out_devices && num_entries > 0) { + out_devices[0] = make_device_id(0); } - else if (param_name == CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR) { - *static_cast(param_value) = 2; - if (param_value_size_ret) { - *param_value_size_ret = sizeof(size_t); - } + if (nullptr != num_devices) + { + *num_devices = 1; + } + if (device_in == make_device_id(0)) { return CL_SUCCESS; } + else if (device_in == make_device_id(1)) { + return CL_INVALID_DEVICE; + } else { - TEST_ABORT(); - return CL_INVALID_OPERATION; + return CL_SUCCESS; } } -void testSubGroups() -{ -// TODO support testing cl_khr_subgroups on 2.0 -#if CL_HPP_TARGET_OPENCL_VERSION >= 210 - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clGetKernelSubGroupInfo_StubWithCallback(clGetKernelSubGroupInfo_testSubGroups); - clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); - clReleaseKernel_ExpectAndReturn(make_kernel(0), CL_SUCCESS); +void testDevice_createSubDevices(void) { + const cl_device_partition_property_ext properties = + CL_DEVICE_PARTITION_EQUALLY_EXT; + std::vector devices(1); - cl::Kernel k(make_kernel(0)); - cl::Device d(make_device_id(0)); - cl_int err; - cl::NDRange ndrange(8, 8); - size_t res1 = k.getSubGroupInfo( - d, ndrange, &err); - size_t res2 = 0; - err = k.getSubGroupInfo( - d, CL_KERNEL_SUB_GROUP_COUNT_FOR_NDRANGE_KHR, ndrange, &res2); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); - TEST_ASSERT_EQUAL(res1, 32); - TEST_ASSERT_EQUAL(res2, 2); -#endif + clCreateSubDevicesEXT_StubWithCallback( + clCreateSubDevicesEXT_testDevice_createSubDevices); + + cl_int ret = devicePool[0].createSubDevices(&properties, &devices); + TEST_ASSERT_EQUAL(CL_SUCCESS, ret); +#ifndef CL_HPP_ENABLE_EXCEPTIONS + ret = devicePool[1].createSubDevices(&properties, &devices); + TEST_ASSERT_EQUAL(CL_INVALID_DEVICE , ret); +#endif /*CL_HPP_ENABLE_EXCEPTIONS*/ + ret = devicePool[2].createSubDevices(&properties, &devices); + TEST_ASSERT_EQUAL(CL_SUCCESS, ret); + TEST_ASSERT_EQUAL(devices[0].get(), make_device_id(0)); } +#endif /*cl_ext_device_fission*/ -/** -* Stub implementation of clGetDeviceInfo that returns an absense of builtin kernels -*/ -static cl_int clGetDeviceInfo_builtin( - cl_device_id id, - cl_device_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, +/**************************************************************************** + * Tests for cl::Semaphore + ****************************************************************************/ +#if defined(cl_khr_semaphore) +void testMoveAssignSemaphoreNonNull(void); +void testMoveAssignSemaphoreNull(void); +void testMoveConstructSemaphoreNonNull(void); +void testMoveConstructSemaphoreNull(void); +MAKE_MOVE_TESTS(Semaphore, make_semaphore_khr, clReleaseSemaphoreKHR, semaphorePool) +#else +void testMoveAssignSemaphoreNonNull(void) {} +void testMoveAssignSemaphoreNull(void) {} +void testMoveConstructSemaphoreNonNull(void) {} +void testMoveConstructSemaphoreNull(void) {} +#endif + +#if defined(cl_khr_semaphore) +static cl_int clEnqueueWaitSemaphoresKHR_testEnqueueWaitSemaphores( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, int num_calls) { - // Test to verify case where empty string is returned - so size is 0 - (void)num_calls; - TEST_ASSERT_EQUAL_HEX(CL_DEVICE_BUILT_IN_KERNELS, param_name); - if (param_value == NULL) { - if (param_value_size_ret != NULL) { - *param_value_size_ret = 0; - } + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(commandQueuePool[1](), command_queue); + TEST_ASSERT_EQUAL(1, num_sema_objects); + TEST_ASSERT_NOT_NULL(sema_objects); + TEST_ASSERT_EQUAL(make_semaphore_khr(1), *sema_objects); + TEST_ASSERT_NOT_NULL(sema_payload_list); + TEST_ASSERT_EQUAL(0, num_events_in_wait_list); + TEST_ASSERT_NULL(event_wait_list); + + if (event != nullptr) + { + *event = make_event(1); } + return CL_SUCCESS; } -void testBuiltInKernels() +void testEnqueueWaitSemaphores(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 120 - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clEnqueueWaitSemaphoresKHR_StubWithCallback(clEnqueueWaitSemaphoresKHR_testEnqueueWaitSemaphores); - cl::Device d0(make_device_id(0)); + VECTOR_CLASS sema_objects; + sema_objects.emplace_back(make_semaphore_khr(1)); + VECTOR_CLASS sema_payloads(1); + cl::Event event; - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_builtin); - cl::string s = d0.getInfo(); -#endif + cl_int status = commandQueuePool[1].enqueueWaitSemaphores(sema_objects, sema_payloads, nullptr, &event); + TEST_ASSERT_EQUAL(CL_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR(make_event(1), event()); + + // prevent destructor from interfering with the test + event() = nullptr; + sema_objects[0]() = nullptr; } -/** - * Stub implementation of clCloneKernel that returns a new kernel object - */ -static cl_kernel clCloneKernel_simplecopy( - cl_kernel k, - cl_int *errcode_ret, +static cl_int clEnqueueSignalSemaphoresKHR_testEnqueueSignalSemaphores( + cl_command_queue command_queue, + cl_uint num_sema_objects, + const cl_semaphore_khr* sema_objects, + const cl_semaphore_payload_khr* sema_payload_list, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, int num_calls) { - // Test to verify case where empty string is returned - so size is 0 - (void)num_calls; - if (errcode_ret != NULL) - *errcode_ret = CL_SUCCESS; - return make_kernel(POOL_MAX); -} + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(commandQueuePool[1](), command_queue); + TEST_ASSERT_EQUAL(1, num_sema_objects); + TEST_ASSERT_NOT_NULL(sema_objects); + TEST_ASSERT_EQUAL(make_semaphore_khr(2), *sema_objects); + TEST_ASSERT_NOT_NULL(sema_payload_list); + TEST_ASSERT_EQUAL(0, num_events_in_wait_list); + TEST_ASSERT_NULL(event_wait_list); + + if (event != nullptr) + { + *event = make_event(2); + } -void testCloneKernel() -{ -#if CL_HPP_TARGET_OPENCL_VERSION >= 210 - clCloneKernel_StubWithCallback(clCloneKernel_simplecopy); - clReleaseKernel_ExpectAndReturn(make_kernel(POOL_MAX), CL_SUCCESS); - cl::Kernel clone = kernelPool[0].clone(); - TEST_ASSERT_EQUAL(clone(), make_kernel(POOL_MAX)); -#endif + return CL_SUCCESS; } -void testEnqueueMapSVM() +void testEnqueueSignalSemaphores(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - std::vector vec(7); - clEnqueueSVMMap_ExpectAndReturn(commandQueuePool[0].get(), CL_TRUE, CL_MAP_READ|CL_MAP_WRITE, static_cast(vec.data()), vec.size()*sizeof(int), 0, NULL, NULL, CL_SUCCESS); - TEST_ASSERT_EQUAL(commandQueuePool[0].enqueueMapSVM(vec, CL_TRUE, CL_MAP_READ|CL_MAP_WRITE), CL_SUCCESS); -#endif + clEnqueueSignalSemaphoresKHR_StubWithCallback(clEnqueueSignalSemaphoresKHR_testEnqueueSignalSemaphores); + + VECTOR_CLASS sema_objects; + sema_objects.emplace_back(make_semaphore_khr(2)); + VECTOR_CLASS sema_payloads(1); + cl::Event event; + + cl_int status = commandQueuePool[1].enqueueSignalSemaphores(sema_objects, sema_payloads, nullptr, &event); + TEST_ASSERT_EQUAL(CL_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR(make_event(2), event()); + + // prevent destructor from interfering with the test + event() = nullptr; + sema_objects[0]() = nullptr; } -void testMapSVM() +cl_semaphore_khr clCreateSemaphoreWithProperties_testSemaphoreWithProperties( + cl_context context, + const cl_semaphore_properties_khr* sema_props, + cl_int* errcode_ret, + int num_calls) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 200 - std::vector vec(1); - clRetainCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clEnqueueSVMMap_ExpectAndReturn(make_command_queue(1), CL_TRUE, CL_MAP_READ|CL_MAP_WRITE, static_cast(vec.data()), vec.size()*sizeof(int), 0, NULL, NULL, CL_SUCCESS); - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - TEST_ASSERT_EQUAL(cl::mapSVM(vec), CL_SUCCESS); -#endif + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(context, contextPool[0]()); + TEST_ASSERT_NOT_NULL(sema_props); + TEST_ASSERT_EQUAL(CL_SEMAPHORE_TYPE_KHR, *sema_props); + TEST_ASSERT_NOT_NULL(errcode_ret); + *errcode_ret = CL_SUCCESS; + return make_semaphore_khr(1); } -// Run after other tests to clear the default state in the header -// using special unit test bypasses. -// We cannot remove the once_flag, so this is a hard fix -// but it means we won't hit cmock release callbacks at the end. -// This is a lot like tearDown but for the header default -// so we do not want to run it for every test. -// The alternative would be to manually modify the test runner -// but we avoid that for now. -void testCleanupHeaderState() +void testSemaphoreWithProperties(void) { - clReleaseCommandQueue_ExpectAndReturn(make_command_queue(1), CL_SUCCESS); - clReleaseContext_ExpectAndReturn(make_context(1), CL_SUCCESS); - clReleaseDevice_ExpectAndReturn(make_device_id(1), CL_SUCCESS); + cl_device_id expected_device = make_device_id(0); + int device_refcount = 1; - cl::CommandQueue::unitTestClearDefault(); - cl::Context::unitTestClearDefault(); - cl::Device::unitTestClearDefault(); - cl::Platform::unitTestClearDefault(); -} + clGetContextInfo_StubWithCallback(clGetContextInfo_device); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); + prepare_deviceRefcounts(1, &expected_device, &device_refcount); -// OpenCL 2.2 APIs: + clCreateSemaphoreWithPropertiesKHR_StubWithCallback(clCreateSemaphoreWithProperties_testSemaphoreWithProperties); -static void CL_CALLBACK test_program_release_callback( - cl_program, - void*) -{ + VECTOR_CLASS sema_props{CL_SEMAPHORE_TYPE_KHR}; + cl_int err = CL_INVALID_OPERATION; + cl::Semaphore sem(contextPool[0], sema_props, &err); + + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL_PTR(make_semaphore_khr(1), sem()); + + // prevent destructor from interfering with the test + sem() = nullptr; } -static cl_int clSetProgramReleaseCallback_set( - cl_program program, - void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), - void *user_data, +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetContext( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret, int num_calls) { (void) num_calls; - - TEST_ASSERT_EQUAL_PTR(make_program(0), program); - TEST_ASSERT_EQUAL_PTR(pfn_notify, test_program_release_callback); + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_CONTEXT_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_context)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_context); + if (param_value != nullptr) + *static_cast(param_value) = make_context(0); return CL_SUCCESS; } -void testSetProgramReleaseCallback() +void testSemaphoreGetInfoContext(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 220 - cl_program program = make_program(0); - int user_data = 0; + cl_context expected_context = make_context(0); + int context_refcount = 1; + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetContext); + prepare_contextRefcounts(1, &expected_context, &context_refcount); - clSetProgramReleaseCallback_StubWithCallback(clSetProgramReleaseCallback_set); - clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + cl_int err = CL_INVALID_OPERATION; - cl::Program prog(program); + cl::Context ctx = semaphorePool[0].getInfo(&err); - prog.setReleaseCallback(test_program_release_callback, &user_data); -#endif + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL_PTR(make_context(0), ctx()); +} + +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetReferenceCount( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret, + int num_calls) +{ + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_REFERENCE_COUNT_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_uint)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_uint); + if (param_value != nullptr) + *static_cast(param_value) = 1; + + return CL_SUCCESS; } -void testSetProgramSpecializationConstantScalar() +void testSemaphoreGetInfoReferenceCount(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 220 - cl_program program = make_program(0); - int sc = 0; + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetReferenceCount); - clSetProgramSpecializationConstant_ExpectAndReturn(program, 0, sizeof(sc), &sc, CL_SUCCESS); - clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + cl_int err = CL_INVALID_OPERATION; - cl::Program prog(program); + cl_uint ret = semaphorePool[0].getInfo(&err); - prog.setSpecializationConstant(0, sc); -#endif + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(1, ret); } -/// Stub for testing boolean specialization constants -static cl_int clSetProgramSpecializationConstant_testBool( - cl_program program, - cl_uint spec_id, - size_t spec_size, - const void* spec_value, +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetProperties( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret, int num_calls) { (void) num_calls; - - TEST_ASSERT_EQUAL_PTR(make_program(0), program); - TEST_ASSERT(spec_id == 0 || spec_id == 1); - TEST_ASSERT_EQUAL(spec_size, 1); - if (spec_id == 0) - { - const cl_uchar *uc_value = (const cl_uchar*)spec_value; - TEST_ASSERT_EQUAL_HEX(uc_value[0], 0); - } - if (spec_id == 1) - { - const cl_uchar *uc_value = (const cl_uchar*)spec_value; - TEST_ASSERT_EQUAL_HEX(uc_value[0], CL_UCHAR_MAX); + static const cl_semaphore_properties_khr test_properties[] = + {CL_SEMAPHORE_TYPE_KHR, + CL_SEMAPHORE_TYPE_BINARY_KHR}; + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_PROPERTIES_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(test_properties)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(test_properties); + if (param_value != nullptr) { + static_cast(param_value)[0] = test_properties[0]; + static_cast(param_value)[1] = test_properties[1]; } + return CL_SUCCESS; } -void testSetProgramSpecializationConstantBool() +void testSemaphoreGetInfoProperties(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 220 - // Spec constant "false" should turn into a call with size one and no bits set. - // Spec constant "true" should turn into a call with size one and all bits set. - cl_program program = make_program(0); - bool scFalse = false; - bool scTrue = true; + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetProperties); - clSetProgramSpecializationConstant_StubWithCallback(clSetProgramSpecializationConstant_testBool); + cl_int err = CL_INVALID_OPERATION; - clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + VECTOR_CLASS ret = semaphorePool[0].getInfo(&err); - cl::Program prog(program); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(2, ret.size()); + TEST_ASSERT_EQUAL(CL_SEMAPHORE_TYPE_KHR, ret[0]); + TEST_ASSERT_EQUAL(CL_SEMAPHORE_TYPE_BINARY_KHR, ret[1]); +} - prog.setSpecializationConstant(0, scFalse); - prog.setSpecializationConstant(1, scTrue); -#endif +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetType( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret, + int num_calls) +{ + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_TYPE_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_semaphore_type_khr)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_semaphore_type_khr); + if (param_value != nullptr) + *static_cast(param_value) = CL_SEMAPHORE_TYPE_BINARY_KHR; + + return CL_SUCCESS; } -void testSetProgramSpecializationConstantPointer() +void testSemaphoreGetInfoType(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 220 - cl_program program = make_program(0); - int scArray[5]; + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetType); - clSetProgramSpecializationConstant_ExpectAndReturn(program, 0, sizeof(scArray), &scArray, CL_SUCCESS); - clReleaseProgram_ExpectAndReturn(program, CL_SUCCESS); + cl_int err = CL_INVALID_OPERATION; - cl::Program prog(program); + cl_semaphore_type_khr ret = semaphorePool[0].getInfo(&err); - prog.setSpecializationConstant(0, sizeof(scArray), scArray); -#endif + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(CL_SEMAPHORE_TYPE_BINARY_KHR, ret); } -// OpenCL 3.0 and cl_khr_extended_versioning Queries +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetPayload( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret, + int num_calls) +{ + (void) num_calls; + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_PAYLOAD_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(cl_semaphore_payload_khr)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(cl_semaphore_payload_khr); + if (param_value != nullptr) + *static_cast(param_value) = 1; -// Assumes the core enums, structures, and macros exactly match -// the extension enums, structures, and macros: + return CL_SUCCESS; +} -static_assert(CL_PLATFORM_NUMERIC_VERSION == CL_PLATFORM_NUMERIC_VERSION_KHR, - "CL_PLATFORM_NUMERIC_VERSION mismatch"); -static_assert(CL_PLATFORM_EXTENSIONS_WITH_VERSION == CL_PLATFORM_EXTENSIONS_WITH_VERSION_KHR, - "CL_PLATFORM_EXTENSIONS_WITH_VERSION mismatch"); +void testSemaphoreGetInfoPayload(void) +{ + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetPayload); -static_assert(CL_DEVICE_NUMERIC_VERSION == CL_DEVICE_NUMERIC_VERSION_KHR, - "CL_DEVICE_NUMERIC_VERSION mismatch"); -static_assert(CL_DEVICE_EXTENSIONS_WITH_VERSION == CL_DEVICE_EXTENSIONS_WITH_VERSION_KHR, - "CL_DEVICE_EXTENSIONS_WITH_VERSION mismatch"); -static_assert(CL_DEVICE_ILS_WITH_VERSION == CL_DEVICE_ILS_WITH_VERSION_KHR, - "CL_DEVICE_ILS_WITH_VERSION mismatch"); -static_assert(CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION == CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION_KHR, - "CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION mismatch"); + cl_int err = CL_INVALID_OPERATION; -static_assert(sizeof(cl_name_version) == sizeof(cl_name_version_khr), - "cl_name_version mismatch"); + cl_semaphore_payload_khr ret = semaphorePool[0].getInfo(&err); -static_assert(CL_MAKE_VERSION(1, 2, 3) == CL_MAKE_VERSION_KHR(1, 2, 3), - "CL_MAKE_VERSION mismatch"); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(1, ret); +} -static cl_int clGetPlatformInfo_extended_versioning( - cl_platform_id id, - cl_platform_info param_name, +#if defined(CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR) +static cl_int clGetSemaphoreInfoKHR_testSemaphoreGetDevices( + cl_semaphore_khr sema_object, + cl_semaphore_info_khr param_name, size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, + void* param_value, + size_t* param_value_size_ret, int num_calls) { - (void)num_calls; - switch (param_name) { - case CL_PLATFORM_NUMERIC_VERSION: - { - if (param_value_size == sizeof(cl_version) && param_value) { - *static_cast(param_value) = CL_MAKE_VERSION(1, 2, 3); - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_version); - } - return CL_SUCCESS; - } - case CL_PLATFORM_EXTENSIONS_WITH_VERSION: - { - static cl_name_version extension = { - CL_MAKE_VERSION(10, 11, 12), - "cl_dummy_extension", - }; - if (param_value_size == sizeof(cl_name_version) && param_value) { - *static_cast(param_value) = extension; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(extension); - } - return CL_SUCCESS; - } - default: break; + (void) num_calls; + static const cl_device_id test_devices[] = + {make_device_id(0), make_device_id(1)}; + TEST_ASSERT_EQUAL_PTR(semaphorePool[0](), sema_object); + TEST_ASSERT_EQUAL_HEX(CL_SEMAPHORE_DEVICE_HANDLE_LIST_KHR, param_name); + TEST_ASSERT(param_value == nullptr || param_value_size >= sizeof(test_devices)); + if (param_value_size_ret != nullptr) + *param_value_size_ret = sizeof(test_devices); + if (param_value != nullptr) { + static_cast(param_value)[0] = test_devices[0]; + static_cast(param_value)[1] = test_devices[1]; } - TEST_FAIL(); - return CL_INVALID_OPERATION; + + return CL_SUCCESS; } -void testPlatformExtendedVersioning_3_0() +void testSemaphoreGetInfoDevicesList(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 300 - cl::Platform p(make_platform_id(1)); + cl_device_id expected_devices[] = {make_device_id(0), make_device_id(1)}; + int device_refcounts[] = {1, 1}; - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_extended_versioning); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); + prepare_deviceRefcounts(ARRAY_SIZE(expected_devices), expected_devices, device_refcounts); - cl_version platformVersion = p.getInfo(); - TEST_ASSERT_EQUAL_HEX(platformVersion, CL_MAKE_VERSION(1, 2, 3)); + clGetSemaphoreInfoKHR_StubWithCallback(clGetSemaphoreInfoKHR_testSemaphoreGetDevices); - std::vector extensions = p.getInfo(); - TEST_ASSERT_EQUAL(extensions.size(), 1); - TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION(10, 11, 12)); - TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 + cl_int err = CL_INVALID_OPERATION; + + VECTOR_CLASS ret = semaphorePool[0].getInfo(&err); + + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(2, ret.size()); + TEST_ASSERT_EQUAL(make_device_id(0), ret[0]()); + TEST_ASSERT_EQUAL(make_device_id(1), ret[1]()); } +#else +void testSemaphoreGetInfoDevicesList(void) {} +#endif -void testPlatformExtendedVersioning_KHR() +void testSemaphoreRetain(void) { -#if CL_HPP_TARGET_OPENCL_VERSION < 300 - cl::Platform p(make_platform_id(1)); + clRetainSemaphoreKHR_ExpectAndReturn(semaphorePool[0](), CL_SUCCESS); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_extended_versioning); + cl_int status = semaphorePool[0].retain(); + TEST_ASSERT_EQUAL(CL_SUCCESS, status); +} - cl_version_khr platformVersion = p.getInfo(); - TEST_ASSERT_EQUAL_HEX(platformVersion, CL_MAKE_VERSION_KHR(1, 2, 3)); +void testSemaphoreRelease(void) +{ + clReleaseSemaphoreKHR_ExpectAndReturn(semaphorePool[0](), CL_SUCCESS); - std::vector extensions = p.getInfo(); - TEST_ASSERT_EQUAL(extensions.size(), 1); - TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION_KHR(10, 11, 12)); - TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); -#endif // CL_HPP_TARGET_OPENCL_VERSION < 300 + cl_int status = semaphorePool[0].release(); + TEST_ASSERT_EQUAL(CL_SUCCESS, status); } +#else +void testEnqueueWaitSemaphores(void) {} +void testEnqueueSignalSemaphores(void) {} +void testSemaphoreWithProperties(void) {} +void testSemaphoreGetInfoContext(void) {} +void testSemaphoreGetInfoReferenceCount(void) {} +void testSemaphoreGetInfoProperties(void) {} +void testSemaphoreGetInfoType(void) {} +void testSemaphoreGetInfoPayload(void) {} +void testSemaphoreGetInfoDevicesList(void) {} +void testSemaphoreRetain(void) {} +void testSemaphoreRelease(void) {} +#endif // cl_khr_semaphore +// Tests for external semaphores: +#if defined(cl_khr_external_semaphore) -// Note: This assumes the core enums, structures, and macros exactly match -// the extension enums, structures, and macros. +static void* make_external_semaphore_handle( + cl_external_semaphore_handle_type_khr handle_type ) +{ + return (void*)(uintptr_t)(handle_type << 16 | 0x1111); +} -static cl_int clGetDeviceInfo_extended_versioning( - cl_device_id id, - cl_device_info param_name, - size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, +static int make_external_semaphore_fd( + cl_external_semaphore_handle_type_khr handle_type) +{ + return (int)(handle_type << 16 | 0x2222); +} + +static cl_int clGetSemaphoreHandleForTypeKHR_GetHandles( + cl_semaphore_khr sema_object, + cl_device_id device, + cl_external_semaphore_handle_type_khr handle_type, + size_t handle_size, + void* handle_ptr, + size_t* handle_size_ret, int num_calls) { - (void)num_calls; - switch (param_name) { - case CL_DEVICE_NUMERIC_VERSION: - { - if (param_value_size == sizeof(cl_version) && param_value) { - *static_cast(param_value) = CL_MAKE_VERSION(1, 2, 3); - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_version); - } - return CL_SUCCESS; - } - case CL_DEVICE_OPENCL_C_NUMERIC_VERSION_KHR: - { - if (param_value_size == sizeof(cl_version_khr) && param_value) { - *static_cast(param_value) = CL_MAKE_VERSION_KHR(4, 5, 6); - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_version_khr); - } - return CL_SUCCESS; - } - case CL_DEVICE_EXTENSIONS_WITH_VERSION: - { - static cl_name_version extension = { - CL_MAKE_VERSION(10, 11, 12), - "cl_dummy_extension", - }; - if (param_value_size == sizeof(cl_name_version) && param_value) { - *static_cast(param_value) = extension; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(extension); - } - return CL_SUCCESS; - } - case CL_DEVICE_ILS_WITH_VERSION: + (void) sema_object; + (void) device; + (void) num_calls; + + switch (handle_type) { +#if defined(cl_khr_external_semaphore_win32) + case CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KHR: + case CL_SEMAPHORE_HANDLE_OPAQUE_WIN32_KMT_KHR: { - static cl_name_version il = { - CL_MAKE_VERSION(20, 21, 22), - "DUMMY_IR", - }; - if (param_value_size == sizeof(cl_name_version) && param_value) { - *static_cast(param_value) = il; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(il); + void* ret = make_external_semaphore_handle(handle_type); + if (handle_size == sizeof(ret) && handle_ptr) { + void** pHandle = static_cast(handle_ptr); + *pHandle = ret; } - return CL_SUCCESS; - } - case CL_DEVICE_BUILT_IN_KERNELS_WITH_VERSION: - { - // Test no built-in kernels: - if (param_value_size_ret) { - *param_value_size_ret = 0; + if (handle_size_ret) { + *handle_size_ret = sizeof(ret); } return CL_SUCCESS; } - case CL_DEVICE_OPENCL_C_ALL_VERSIONS: +#endif +#if defined(cl_khr_external_semaphore_opaque_fd) + case CL_SEMAPHORE_HANDLE_OPAQUE_FD_KHR: { - static cl_name_version opencl_c = { - CL_MAKE_VERSION(30, 31, 32), - "OpenCL C", - }; - if (param_value_size == sizeof(cl_name_version) && param_value) { - *static_cast(param_value) = opencl_c; + int ret = make_external_semaphore_fd(handle_type); + if (handle_size == sizeof(ret) && handle_ptr) { + int* pHandle = static_cast(handle_ptr); + *pHandle = ret; } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(opencl_c); + if (handle_size_ret) { + *handle_size_ret = sizeof(ret); } return CL_SUCCESS; } - case CL_DEVICE_OPENCL_C_FEATURES: +#endif +#if defined(cl_khr_external_semaphore_opaque_fd) + case CL_SEMAPHORE_HANDLE_SYNC_FD_KHR: { - static cl_name_version opencl_c_features[] = { - { - CL_MAKE_VERSION(40, 41, 42), - "__opencl_c_feature", - }, - { - CL_MAKE_VERSION(40, 43, 44), - "__opencl_c_fancy_feature", - }, - }; - if (param_value_size == sizeof(opencl_c_features) && param_value) { - cl_name_version* feature = static_cast(param_value); - const int numFeatures = ARRAY_SIZE(opencl_c_features); - for (int i = 0; i < numFeatures; i++) { - feature[i] = opencl_c_features[i]; - } + int ret = make_external_semaphore_fd(handle_type); + if (handle_size == sizeof(ret) && handle_ptr) { + int* pHandle = static_cast(handle_ptr); + *pHandle = ret; } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(opencl_c_features); + if (handle_size_ret) { + *handle_size_ret = sizeof(ret); } return CL_SUCCESS; } +#endif default: break; } TEST_FAIL(); return CL_INVALID_OPERATION; } -void testDeviceExtendedVersioning_3_0() +void testTemplateGetSemaphoreHandleForTypeKHR(void) { -#if CL_HPP_TARGET_OPENCL_VERSION >= 300 clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_3_0); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); - cl::Device d0(make_device_id(0)); + cl::Device device(make_device_id(0)); - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_extended_versioning); + clGetSemaphoreHandleForTypeKHR_StubWithCallback(clGetSemaphoreHandleForTypeKHR_GetHandles); - cl_version deviceVersion = d0.getInfo(); - TEST_ASSERT_EQUAL_HEX(deviceVersion, CL_MAKE_VERSION(1, 2, 3)); + cl::Semaphore semaphore; +#if defined(cl_khr_external_semaphore_opaque_fd) + { + auto fd0 = semaphore.getHandleForTypeKHR(device); + TEST_ASSERT_EQUAL(fd0, make_external_semaphore_fd(cl::ExternalSemaphoreType::OpaqueFd)); + } +#endif +#if defined(cl_khr_external_semaphore_sync_fd) + { + auto fd1 = semaphore.getHandleForTypeKHR(device); + TEST_ASSERT_EQUAL(fd1, make_external_semaphore_fd(cl::ExternalSemaphoreType::SyncFd)); + } +#endif +#if defined(cl_khr_external_semaphore_win32) + { + auto handle1 = semaphore.getHandleForTypeKHR(device); + TEST_ASSERT_EQUAL(handle1, make_external_semaphore_handle(cl::ExternalSemaphoreType::OpaqueWin32)); + auto handle2 = semaphore.getHandleForTypeKHR(device); + TEST_ASSERT_EQUAL(handle2, make_external_semaphore_handle(cl::ExternalSemaphoreType::OpaqueWin32Kmt)); + } +#endif +} +#else +void testTemplateGetSemaphoreHandleForTypeKHR() {} +#endif // defined(cl_khr_external_semaphore) - std::vector extensions = d0.getInfo(); - TEST_ASSERT_EQUAL(extensions.size(), 1); - TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION(10, 11, 12)); - TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); +/**************************************************************************** + * Tests for cl_khr_external_memory + ****************************************************************************/ +#ifdef cl_khr_external_memory +static cl_int clEnqueueAcquireExternalMemObjectsKHR_testEnqueueAcquireExternalMemObjects( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, + int num_calls) +{ + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(commandQueuePool[0](), command_queue); + TEST_ASSERT_EQUAL(1, num_mem_objects); + TEST_ASSERT_EQUAL(make_mem(0), *mem_objects); + TEST_ASSERT_EQUAL(0, num_events_in_wait_list); + TEST_ASSERT_NULL(event_wait_list); - std::vector ils = d0.getInfo(); - TEST_ASSERT_EQUAL(ils.size(), 1); - TEST_ASSERT_EQUAL_HEX(ils[0].version, CL_MAKE_VERSION(20, 21, 22)); - TEST_ASSERT_EQUAL_STRING(ils[0].name, "DUMMY_IR"); + if (event != nullptr) + { + *event = make_event(0); + } - std::vector opencl_c = d0.getInfo(); - TEST_ASSERT_EQUAL(opencl_c.size(), 1); - TEST_ASSERT_EQUAL_HEX(opencl_c[0].version, CL_MAKE_VERSION(30, 31, 32)); - TEST_ASSERT_EQUAL_STRING(opencl_c[0].name, "OpenCL C"); + return CL_SUCCESS; +} - std::vector opencl_c_features = d0.getInfo(); - TEST_ASSERT_EQUAL(opencl_c_features.size(), 2); - TEST_ASSERT_EQUAL_HEX(opencl_c_features[0].version, CL_MAKE_VERSION(40, 41, 42)); - TEST_ASSERT_EQUAL_STRING(opencl_c_features[0].name, "__opencl_c_feature"); - TEST_ASSERT_EQUAL_HEX(opencl_c_features[1].version, CL_MAKE_VERSION(40, 43, 44)); - TEST_ASSERT_EQUAL_STRING(opencl_c_features[1].name, "__opencl_c_fancy_feature"); +void testEnqueueAcquireExternalMemObjects(void) +{ + clGetCommandQueueInfo_StubWithCallback(clGetCommandQueueInfo_testCommandQueueGetDevice); + clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); - std::vector builtInKernels = d0.getInfo(); - TEST_ASSERT_EQUAL(builtInKernels.size(), 0); -#endif // CL_HPP_TARGET_OPENCL_VERSION >= 300 + clEnqueueAcquireExternalMemObjectsKHR_StubWithCallback(clEnqueueAcquireExternalMemObjectsKHR_testEnqueueAcquireExternalMemObjects); + + VECTOR_CLASS mem_objects; + mem_objects.emplace_back(make_mem(0), false); + cl::Event event; + + cl_int status = commandQueuePool[0].enqueueAcquireExternalMemObjects(mem_objects, nullptr, &event); + + TEST_ASSERT_EQUAL(CL_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR(make_event(0), event()); + + // prevent destructor from interfering with the test + event() = nullptr; + mem_objects[0]() = nullptr; } -void testDeviceExtendedVersioning_KHR() +static cl_int clEnqueueReleaseExternalMemObjectsKHR_testEnqueueReleaseExternalMemObjects( + cl_command_queue command_queue, + cl_uint num_mem_objects, + const cl_mem* mem_objects, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event, + int num_calls) { -#if CL_HPP_TARGET_OPENCL_VERSION < 300 + TEST_ASSERT_EQUAL(0, num_calls); + TEST_ASSERT_EQUAL_PTR(commandQueuePool[0](), command_queue); + TEST_ASSERT_EQUAL(1, num_mem_objects); + TEST_ASSERT_EQUAL(make_mem(0), *mem_objects); + TEST_ASSERT_EQUAL(0, num_events_in_wait_list); + TEST_ASSERT_NULL(event_wait_list); + + if (event != nullptr) + { + *event = make_event(0); + } + + return CL_SUCCESS; +} + +void testEnqueueReleaseExternalMemObjects(void) +{ + clGetCommandQueueInfo_StubWithCallback(clGetCommandQueueInfo_testCommandQueueGetDevice); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_1_1); - cl::Device d0(make_device_id(0)); + clEnqueueReleaseExternalMemObjectsKHR_StubWithCallback(clEnqueueReleaseExternalMemObjectsKHR_testEnqueueReleaseExternalMemObjects); - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_extended_versioning); + VECTOR_CLASS mem_objects; + mem_objects.emplace_back(make_mem(0), false); + cl::Event event; - cl_version_khr deviceVersion = d0.getInfo(); - TEST_ASSERT_EQUAL_HEX(deviceVersion, CL_MAKE_VERSION_KHR(1, 2, 3)); + cl_int status = commandQueuePool[0].enqueueReleaseExternalMemObjects(mem_objects, nullptr, &event); - cl_version_khr cVersion = d0.getInfo(); - TEST_ASSERT_EQUAL_HEX(cVersion, CL_MAKE_VERSION_KHR(4, 5, 6)); + TEST_ASSERT_EQUAL(CL_SUCCESS, status); + TEST_ASSERT_EQUAL_PTR(make_event(0), event()); - std::vector extensions = d0.getInfo(); - TEST_ASSERT_EQUAL(extensions.size(), 1); - TEST_ASSERT_EQUAL_HEX(extensions[0].version, CL_MAKE_VERSION_KHR(10, 11, 12)); - TEST_ASSERT_EQUAL_STRING(extensions[0].name, "cl_dummy_extension"); + // prevent destructor from interfering with the test + event() = nullptr; + mem_objects[0]() = nullptr; +} - std::vector ils = d0.getInfo(); - TEST_ASSERT_EQUAL(ils.size(), 1); - TEST_ASSERT_EQUAL_HEX(ils[0].version, CL_MAKE_VERSION_KHR(20, 21, 22)); - TEST_ASSERT_EQUAL_STRING(ils[0].name, "DUMMY_IR"); +#else +void testEnqueueAcquireExternalMemObjects(void) {} +void testEnqueueReleaseExternalMemObjects(void) {} +#endif // cl_khr_external_memory - std::vector builtInKernels = d0.getInfo(); - TEST_ASSERT_EQUAL(builtInKernels.size(), 0); -#endif // CL_HPP_TARGET_OPENCL_VERSION < 300 +/**************************************************************************** + * Tests for allocate and deallocate API (stubs for clSVMAlloc, clSVMFree, clEnqueueSVMMap) + ****************************************************************************/ +int *testMemory; +void *clSVMAllocARM_stubForMemoryAllocation(cl_context context,cl_svm_mem_flags flags, + size_t size, cl_uint alignment, int cmock_num_calls) +{ + (void) context; + (void) flags; + (void) alignment; + (void) cmock_num_calls; + + TEST_ASSERT_EQUAL_HEX(size, 3 * sizeof(int)); + testMemory = new int[size / sizeof(int)]; + return testMemory; +} +cl_int clEnqueueSVMMap_stubForMemoryAllocation(cl_command_queue command_queue, cl_bool blocking_map, cl_map_flags flags, void* svm_ptr, size_t size, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, cl_event* event, int cmock_num_calls) +{ + (void) command_queue; + (void) blocking_map; + (void) flags; + (void) num_events_in_wait_list; + (void) event_wait_list; + (void) event; + (void) cmock_num_calls; + + TEST_ASSERT_EQUAL_PTR(svm_ptr, testMemory); + TEST_ASSERT_EQUAL_HEX(size, 3 * sizeof(int)); + return CL_SUCCESS; } +void clSVMFree_stubForMemoryAllocation(cl_context context, void *svm_pointer, + int cmock_num_calls) +{ + (void) context; + (void) cmock_num_calls; -static cl_int clGetDeviceInfo_uuid_pci_bus_info( - cl_device_id id, - cl_device_info param_name, + TEST_ASSERT_EQUAL_PTR(svm_pointer, testMemory); + delete[] (int*) svm_pointer; +} +void testSVMMemoryAllocation(void) +{ +#if CL_HPP_TARGET_OPENCL_VERSION >= 200 + cl::SVMAllocator> svmAllocator; + + clSVMAlloc_StubWithCallback(clSVMAllocARM_stubForMemoryAllocation); + clEnqueueSVMMap_StubWithCallback(clEnqueueSVMMap_stubForMemoryAllocation); + clSVMFree_StubWithCallback(clSVMFree_stubForMemoryAllocation); + + int *ptr = svmAllocator.allocate(3); + TEST_ASSERT_EQUAL_PTR(ptr,testMemory); + clSVMFree_Expect(0, ptr); + svmAllocator.deallocate(ptr,3); +#endif +} + +#if defined(cl_ext_image_requirements_info) +constexpr size_t TEST_SIZE_TYPE_VALUE = 4; +constexpr cl_uint TEST_UINT_VALUE = 256; + +static cl_int clGetImageRequirementsInfoEXT_GetInfo( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + const cl_image_format* image_format, + const cl_image_desc* image_desc, + cl_image_requirements_info_ext param_name, size_t param_value_size, - void *param_value, - size_t *param_value_size_ret, + void* param_value, + size_t* param_value_size_ret, int num_calls) { - (void)num_calls; - switch (param_name) { -#if defined(cl_khr_device_uuid) - case CL_DEVICE_UUID_KHR: - case CL_DRIVER_UUID_KHR: + (void) context; + (void) properties; + (void) flags; + (void) image_format; + (void) image_desc; + (void) num_calls; + + switch(param_name) { - if (param_value_size == CL_UUID_SIZE_KHR && param_value) { - cl_uchar* pUUID = static_cast(param_value); - cl_uchar start = - (param_name == CL_DEVICE_UUID_KHR) ? 1 : - (param_name == CL_DRIVER_UUID_KHR) ? 2 : - 0; - for (int i = 0; i < CL_UUID_SIZE_KHR; i++) { - pUUID[i] = i + start; + case CL_IMAGE_REQUIREMENTS_ROW_PITCH_ALIGNMENT_EXT: + case CL_IMAGE_REQUIREMENTS_BASE_ADDRESS_ALIGNMENT_EXT: +#if defined(cl_ext_image_from_buffer) + case CL_IMAGE_REQUIREMENTS_SLICE_PITCH_ALIGNMENT_EXT: +#endif + case CL_IMAGE_REQUIREMENTS_SIZE_EXT: + { + size_t ret = 4; + if (param_value_size == sizeof(ret) && param_value) { + *static_cast(param_value) = ret; } - } - if (param_value_size_ret) { - *param_value_size_ret = CL_UUID_SIZE_KHR; - } - return CL_SUCCESS; - } - case CL_DEVICE_LUID_VALID_KHR: - { - if (param_value_size == sizeof(cl_bool) && param_value) { - *static_cast(param_value) = CL_TRUE; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_bool); - } - return CL_SUCCESS; - } - case CL_DEVICE_LUID_KHR: - { - if (param_value_size == CL_LUID_SIZE_KHR && param_value) { - cl_uchar* pLUID = static_cast(param_value); - cl_uchar start = 3; - for (int i = 0; i < CL_LUID_SIZE_KHR; i++) { - pLUID[i] = i + start; + + if (param_value_size_ret) { + *param_value_size_ret = sizeof(ret); } + + return CL_SUCCESS; } - if (param_value_size_ret) { - *param_value_size_ret = CL_LUID_SIZE_KHR; - } - return CL_SUCCESS; - } - case CL_DEVICE_NODE_MASK_KHR: - { - if (param_value_size == sizeof(cl_uint) && param_value) { - *static_cast(param_value) = 0xA5A5; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_uint); - } - return CL_SUCCESS; - } -#endif -#if defined(cl_khr_pci_bus_info) - case CL_DEVICE_PCI_BUS_INFO_KHR: - { - if (param_value_size == sizeof(cl_device_pci_bus_info_khr) && param_value) { - cl_device_pci_bus_info_khr* pInfo = static_cast(param_value); - pInfo->pci_domain = 0x11; - pInfo->pci_bus = 0x22; - pInfo->pci_device = 0x33; - pInfo->pci_function = 0x44; - } - if (param_value_size_ret) { - *param_value_size_ret = sizeof(cl_device_pci_bus_info_khr); + case CL_IMAGE_REQUIREMENTS_MAX_WIDTH_EXT: + case CL_IMAGE_REQUIREMENTS_MAX_HEIGHT_EXT: + case CL_IMAGE_REQUIREMENTS_MAX_DEPTH_EXT: + case CL_IMAGE_REQUIREMENTS_MAX_ARRAY_SIZE_EXT: + { + cl_uint ret = TEST_UINT_VALUE; + if (param_value_size == sizeof(ret) && param_value) { + *static_cast(param_value) = ret; + } + + if (param_value_size_ret) { + *param_value_size_ret = sizeof(ret); + } + + return CL_SUCCESS; } - return CL_SUCCESS; - } -#endif - default: break; + default: break; } TEST_FAIL(); return CL_INVALID_OPERATION; } -void testDeviceUUID_KHR() +void testTemplateGetImageRequirementsInfo(void) { -#if defined(cl_khr_device_uuid) + cl::Context context(make_context(0)); + cl_device_id device_expect = make_device_id(0); + int device_refcount = 1; + + prepare_deviceRefcounts(1, &device_expect, &device_refcount); + + clGetContextInfo_StubWithCallback(clGetContextInfo_device); clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + clReleaseContext_ExpectAndReturn(make_context(0), CL_SUCCESS); - cl::Device d0(make_device_id(0)); + clGetImageRequirementsInfoEXT_StubWithCallback(clGetImageRequirementsInfoEXT_GetInfo); - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_uuid_pci_bus_info); + auto info0 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info0, TEST_SIZE_TYPE_VALUE); - std::array dev_uuid = d0.getInfo(); - for (int i = 0; i < CL_UUID_SIZE_KHR; i++) { - TEST_ASSERT_EQUAL_UINT8(i + 1, dev_uuid[i]); - } - std::array drv_uuid = d0.getInfo(); - for (int i = 0; i < CL_UUID_SIZE_KHR; i++) { - TEST_ASSERT_EQUAL_UINT8(i + 2, drv_uuid[i]); - } + auto info1 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info1, TEST_SIZE_TYPE_VALUE); - cl_bool valid = d0.getInfo(); - TEST_ASSERT_EQUAL(CL_TRUE, valid); - std::array luid = d0.getInfo(); - for (int i = 0; i < CL_LUID_SIZE_KHR; i++) { - TEST_ASSERT_EQUAL_UINT8(i + 3, luid[i]); - } + auto info2 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info2, TEST_SIZE_TYPE_VALUE); - cl_uint nodeMask = d0.getInfo(); - TEST_ASSERT_EQUAL(0xA5A5, nodeMask); +#if defined(cl_ext_image_from_buffer) + auto info3 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info3, TEST_SIZE_TYPE_VALUE); #endif + + auto info4 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info4, TEST_UINT_VALUE); + + auto info5 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info5, TEST_UINT_VALUE); + + auto info6 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info6, TEST_UINT_VALUE); + + auto info7 = context.getImageRequirementsInfoExt(); + TEST_ASSERT_EQUAL(info7, TEST_UINT_VALUE); } +#else +void testTemplateGetImageRequirementsInfo() {} +#endif // cl_ext_image_requirements_info -void testDevicePCIBusInfo_KHR() +static cl_mem clCreateFromGLBuffer_testgetObjectInfo(cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + cl_int *errcode_ret, + int cmock_num_calls) { -#if defined(cl_khr_pci_bus_info) - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_platform); - clGetPlatformInfo_StubWithCallback(clGetPlatformInfo_version_2_0); - clReleaseDevice_ExpectAndReturn(make_device_id(0), CL_SUCCESS); + (void) cmock_num_calls; - cl::Device d0(make_device_id(0)); + TEST_ASSERT_EQUAL(0, bufobj); + TEST_ASSERT_EQUAL_PTR(make_context(0), context); + TEST_ASSERT_EQUAL(0, flags); + if (errcode_ret) + *errcode_ret = CL_SUCCESS; + return make_mem(0); +} - clGetDeviceInfo_StubWithCallback(clGetDeviceInfo_uuid_pci_bus_info); +static cl_int clGetGLObjectInfo_testgetObjectInfo(cl_mem memobj, + cl_gl_object_type *type, + cl_GLuint *gl_object_name, + int cmock_num_calls) +{ + (void) cmock_num_calls; - cl_device_pci_bus_info_khr info = d0.getInfo(); - TEST_ASSERT_EQUAL_HEX(0x11, info.pci_domain); - TEST_ASSERT_EQUAL_HEX(0x22, info.pci_bus); - TEST_ASSERT_EQUAL_HEX(0x33, info.pci_device); - TEST_ASSERT_EQUAL_HEX(0x44, info.pci_function); -#endif + TEST_ASSERT_EQUAL(memobj, make_mem(0)); + *type = CL_GL_OBJECT_BUFFER; + + *gl_object_name = 0; + return CL_SUCCESS; +} + +void testgetObjectInfo(void) +{ + clGetGLObjectInfo_StubWithCallback(clGetGLObjectInfo_testgetObjectInfo); + clCreateFromGLBuffer_StubWithCallback( + clCreateFromGLBuffer_testgetObjectInfo); + clReleaseMemObject_ExpectAndReturn(make_mem(0), CL_SUCCESS); + + cl_mem_flags flags = 0; + cl_GLuint bufobj = 0; + cl_int err = 0; + cl::BufferGL buffer(contextPool[0], flags, bufobj, &err); + TEST_ASSERT_EQUAL_PTR(make_mem(0), buffer()); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + + cl_gl_object_type type = CL_GL_OBJECT_TEXTURE2D_ARRAY; + err = buffer.getObjectInfo(&type, &bufobj); + TEST_ASSERT_EQUAL(CL_SUCCESS, err); + TEST_ASSERT_EQUAL(type, CL_GL_OBJECT_BUFFER); + TEST_ASSERT_EQUAL(bufobj, 0); +} +#if CL_HPP_TARGET_OPENCL_VERSION >= 210 +static cl_int clGetHostTimer_testgetHostTimer(cl_device_id device, + cl_ulong *host_timestamp, + int num_calls) { + TEST_ASSERT_EQUAL_PTR(devicePool[0](), device); + TEST_ASSERT_EQUAL(0, num_calls); + *host_timestamp = 1; + return 0; } +void testgetHostTimer(void) { + cl_ulong retVal = 0; + cl_int *error = nullptr; + clGetHostTimer_StubWithCallback(clGetHostTimer_testgetHostTimer); + retVal = devicePool[0].getHostTimer(error); + TEST_ASSERT_EQUAL(retVal, 1); +} +#else +void testgetHostTimer(void) {} +#endif // CL_HPP_TARGET_OPENCL_VERSION >= 210 } // extern "C" diff --git a/deps/opencl-headers-hpp/tests/test_versions.cpp b/deps/opencl-headers-hpp/tests/test_versions.cpp new file mode 100644 index 000000000..e0bf91bc9 --- /dev/null +++ b/deps/opencl-headers-hpp/tests/test_versions.cpp @@ -0,0 +1,24 @@ +// +// 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 +#include + +int main(void) +{ + std::cout << "opencl.hpp version permutation test PASSED.\n"; + return 0; +} \ No newline at end of file From e2f83247f955811c8cbeccf5c4823f373a61ab55 Mon Sep 17 00:00:00 2001 From: Vladimir Kutuev Date: Mon, 19 May 2025 18:03:55 +0300 Subject: [PATCH 3/8] gh-233: update opencl-icd-loader dependency --- .../.github/workflows/linux.yml | 268 ------- .../.github/workflows/macos.yml | 96 --- .../.github/workflows/presubmit.yml | 725 ++++++++++++++++++ .../.github/workflows/release.yml | 74 ++ .../.github/workflows/windows.yml | 194 ----- deps/opencl-icd-loader/.gitignore | 20 +- deps/opencl-icd-loader/CMakeLists.txt | 120 ++- deps/opencl-icd-loader/OpenCL.pc.in | 9 + deps/opencl-icd-loader/README.md | 8 +- .../cmake/DebSourcePkg.cmake | 160 ++++ deps/opencl-icd-loader/cmake/JoinPaths.cmake | 26 + deps/opencl-icd-loader/cmake/Package.cmake | 40 + .../cmake/PackageSetup.cmake | 112 +++ deps/opencl-icd-loader/loader/cllayerinfo.c | 132 ++++ deps/opencl-icd-loader/loader/icd.c | 21 +- deps/opencl-icd-loader/loader/icd.h | 102 ++- deps/opencl-icd-loader/loader/icd_dispatch.c | 55 +- .../loader/icd_dispatch_generated.c | 379 +++++---- deps/opencl-icd-loader/loader/icd_platform.h | 17 +- deps/opencl-icd-loader/loader/icd_version.h | 57 ++ .../loader/linux/icd_linux.c | 247 +++--- .../loader/windows/OpenCL-mingw-i686.def | 162 ++++ .../loader/windows/OpenCL.rc | 20 +- .../loader/windows/icd_windows.c | 156 +++- .../loader/windows/icd_windows_apppackage.c | 123 +++ .../loader/windows/icd_windows_apppackage.cpp | 176 ----- .../loader/windows/icd_windows_apppackage.h | 3 - .../loader/windows/icd_windows_dxgk.c | 25 +- .../loader/windows/icd_windows_hkr.c | 23 +- .../scripts/icd_dispatch_generated.c.mako | 14 +- .../scripts/icd_print_layer_generated.c.mako | 4 +- deps/opencl-icd-loader/test/CMakeLists.txt | 33 +- deps/opencl-icd-loader/test/driver_stub/cl.c | 62 +- .../test/inc/platform/icd_test_log.h | 14 +- .../test/layer/icd_print_layer.c | 41 +- .../test/layer/icd_print_layer_generated.c | 364 ++++----- .../test/loader_test/icd_test_match.c | 2 +- .../opencl-icd-loader/test/loader_test/main.c | 23 +- .../test/loader_test/test_buffer_object.c | 2 +- .../test/loader_test/test_cl_runtime.c | 2 +- .../test/loader_test/test_clgl.c | 6 +- .../test/loader_test/test_create_calls.c | 24 +- .../test/loader_test/test_image_objects.c | 2 +- .../test/loader_test/test_kernel.c | 2 +- .../test/loader_test/test_platforms.c | 2 +- .../test/loader_test/test_program_objects.c | 13 +- .../test/loader_test/test_sampler_objects.c | 2 +- .../test/pkgconfig/bare/CMakeLists.txt | 15 +- .../test/pkgconfig/pkgconfig.c | 16 +- .../test/pkgconfig/pkgconfig/CMakeLists.txt | 60 ++ .../test/pkgconfig/sdk/CMakeLists.txt | 15 +- 51 files changed, 2884 insertions(+), 1384 deletions(-) delete mode 100644 deps/opencl-icd-loader/.github/workflows/linux.yml delete mode 100644 deps/opencl-icd-loader/.github/workflows/macos.yml create mode 100644 deps/opencl-icd-loader/.github/workflows/presubmit.yml create mode 100644 deps/opencl-icd-loader/.github/workflows/release.yml delete mode 100644 deps/opencl-icd-loader/.github/workflows/windows.yml create mode 100644 deps/opencl-icd-loader/OpenCL.pc.in create mode 100644 deps/opencl-icd-loader/cmake/DebSourcePkg.cmake create mode 100644 deps/opencl-icd-loader/cmake/JoinPaths.cmake create mode 100644 deps/opencl-icd-loader/cmake/Package.cmake create mode 100644 deps/opencl-icd-loader/cmake/PackageSetup.cmake create mode 100644 deps/opencl-icd-loader/loader/cllayerinfo.c create mode 100644 deps/opencl-icd-loader/loader/icd_version.h create mode 100644 deps/opencl-icd-loader/loader/windows/OpenCL-mingw-i686.def create mode 100644 deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.c delete mode 100644 deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.cpp create mode 100644 deps/opencl-icd-loader/test/pkgconfig/pkgconfig/CMakeLists.txt diff --git a/deps/opencl-icd-loader/.github/workflows/linux.yml b/deps/opencl-icd-loader/.github/workflows/linux.yml deleted file mode 100644 index 32703836c..000000000 --- a/deps/opencl-icd-loader/.github/workflows/linux.yml +++ /dev/null @@ -1,268 +0,0 @@ -name: Linux - -on: [push, pull_request] - -jobs: - cmake-minimum: - runs-on: ${{ matrix.OS }} - strategy: - matrix: - OS: [ubuntu-18.04] - COMPILER: [gcc-7, gcc-8, clang-8, clang-10] - EXT: [ON, OFF] - GEN: [Unix Makefiles] - CONFIG: [Debug, Release] - STD: [99, 11] - BIN: [32, 64] - CMAKE: [3.1.3, 3.21.2] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{ matrix.CMAKE }}/cmake-${{ matrix.CMAKE }}-Linux-x86_64.tar.gz - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Create Build Environment - run: sudo apt-get update -q; - if [[ "${{matrix.GEN}}" =~ "Ninja" && ! `which ninja` ]]; then sudo apt install -y ninja-build; fi; - sudo apt install -y ${{matrix.COMPILER}}; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "gcc" ]]; then sudo apt install -y ${{matrix.COMPILER}}-multilib; fi; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "clang" ]]; then sudo apt install -y gcc-multilib ; fi; - mkdir -p /opt/Kitware/CMake; - wget -c $CMAKE_URL -O - | tar -xz --directory /opt/Kitware/CMake; - mv /opt/Kitware/CMake/cmake-${{ matrix.CMAKE }}-* /opt/Kitware/CMake/${{ matrix.CMAKE }} - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B$GITHUB_WORKSPACE/external/OpenCL-Headers/build - -H$GITHUB_WORKSPACE/external/OpenCL-Headers && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - -- - -j`nproc` - - - name: Configure - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-Wall -Wextra -Werror -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B$GITHUB_WORKSPACE/build - -H$GITHUB_WORKSPACE - - - name: Build - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - -- - -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: bash - run: $CTEST_EXE --output-on-failure --parallel `nproc` - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/libOpenCLDriverStub.so - -B$GITHUB_WORKSPACE/build/downstream/bare - -H$GITHUB_WORKSPACE/test/pkgconfig/bare ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/bare ; - cd $GITHUB_WORKSPACE/build/downstream/bare ; - $CTEST_EXE --output-on-failure - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/libOpenCLDriverStub.so - -B$GITHUB_WORKSPACE/build/downstream/sdk - -H$GITHUB_WORKSPACE/test/pkgconfig/sdk ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/sdk ; - cd $GITHUB_WORKSPACE/build/downstream/sdk ; - $CTEST_EXE --output-on-failure - - - - - - cmake-latest: - runs-on: ${{ matrix.OS }} - strategy: - matrix: - OS : [ubuntu-20.04] - COMPILER: [gcc-9, gcc-11, clang-11, clang-13] - EXT: [ON, OFF] - GEN: [Ninja Multi-Config] - STD: [99, 11, 17] - BIN: [32, 64] - CMAKE: [3.21.2] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{ matrix.CMAKE }}/cmake-${{ matrix.CMAKE }}-Linux-x86_64.tar.gz - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Create Build Environment - run: sudo apt-get update -q; - if [[ "${{matrix.GEN}}" =~ "Ninja" && ! `which ninja` ]]; then sudo apt install -y ninja-build; fi; - if [[ "${{matrix.COMPILER}}" =~ "gcc-11" ]]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi; - if [[ "${{matrix.COMPILER}}" =~ "clang-13" ]]; then wget -q -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -; sudo apt-add-repository -y 'deb [arch=amd64] https://apt.llvm.org/focal/ llvm-toolchain-focal-13 main'; fi; - sudo apt install -y ${{matrix.COMPILER}}; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "gcc" ]]; then sudo apt install -y ${{matrix.COMPILER}}-multilib; fi; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "clang" ]]; then sudo apt install -y gcc-multilib ; fi; - mkdir -p /opt/Kitware/CMake; - wget -c $CMAKE_URL -O - | tar -xz --directory /opt/Kitware/CMake; - mv /opt/Kitware/CMake/cmake-${{ matrix.CMAKE }}-* /opt/Kitware/CMake/${{ matrix.CMAKE }} - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build - -S $GITHUB_WORKSPACE/external/OpenCL-Headers; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - --config Release - -- - -j`nproc` - - - name: Configure - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_C_FLAGS="-Wall -Wextra -Werror -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B $GITHUB_WORKSPACE/build - -S $GITHUB_WORKSPACE - - - name: Build - shell: bash - run: | - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release -- -j`nproc`; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug -- -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: bash - run: | - $CTEST_EXE --output-on-failure -C Release --parallel `nproc`; - $CTEST_EXE --output-on-failure -C Debug --parallel `nproc`; - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - --config Release - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.so - -B $GITHUB_WORKSPACE/build/downstream/bare - -S $GITHUB_WORKSPACE/test/pkgconfig/bare; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/bare; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.so - -B $GITHUB_WORKSPACE/build/downstream/sdk - -S $GITHUB_WORKSPACE/test/pkgconfig/sdk; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/sdk; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; diff --git a/deps/opencl-icd-loader/.github/workflows/macos.yml b/deps/opencl-icd-loader/.github/workflows/macos.yml deleted file mode 100644 index 4144a2bba..000000000 --- a/deps/opencl-icd-loader/.github/workflows/macos.yml +++ /dev/null @@ -1,96 +0,0 @@ -name: MacOS - -on: [push, pull_request] - -jobs: - macos-gcc: - runs-on: macos-latest - strategy: - matrix: - VER: [9, 10, 11] - EXT: [ON, OFF] - GEN: [Xcode, Ninja Multi-Config] - STD: [99, 11] # 90 results in errors - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Create Build Environment - run: | - cmake -E make_directory $GITHUB_WORKSPACE/build; - cmake -E make_directory $GITHUB_WORKSPACE/install; - if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi; - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: cmake - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w" - -D CMAKE_C_COMPILER=/usr/local/bin/gcc-${{matrix.VER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -S $GITHUB_WORKSPACE/external/OpenCL-Headers - -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && - cmake - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - --config Release - --parallel `sysctl -n hw.logicalcpu` - - - name: Configure CMake - # no -Werror during configuration because: - # warning: ISO C forbids assignment between function pointer and ‘void *’ [-Wpedantic] - # warning: unused parameter [-Wunused-parameter] - shell: bash - run: cmake - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -Wno-format" - -D CMAKE_C_COMPILER=/usr/local/bin/gcc-${{matrix.VER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -S $GITHUB_WORKSPACE - -B $GITHUB_WORKSPACE/build - - - name: Build (Xcode) - if: matrix.GEN == 'Xcode' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` - cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` - cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: bash - run: | - ctest -C Release --output-on-failure --parallel `sysctl -n hw.logicalcpu` - ctest -C Debug --output-on-failure --parallel `sysctl -n hw.logicalcpu` - - - name: Install (Xcode) - if: matrix.GEN == 'Xcode' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --target install - - - name: Install (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: bash - run: | - cmake --build $GITHUB_WORKSPACE/build --config Release --target install \ No newline at end of file diff --git a/deps/opencl-icd-loader/.github/workflows/presubmit.yml b/deps/opencl-icd-loader/.github/workflows/presubmit.yml new file mode 100644 index 000000000..ccada19b7 --- /dev/null +++ b/deps/opencl-icd-loader/.github/workflows/presubmit.yml @@ -0,0 +1,725 @@ +name: Presubmit + +on: + push: + paths-ignore: + - '**/*.md' + pull_request: + paths-ignore: + - '**/*.md' + +jobs: + linux: + runs-on: ubuntu-latest + defaults: + run: + shell: bash + strategy: + matrix: + CMAKE: [3.26.4] + C_COMPILER: + - gcc-11 + - gcc-13 + - clang-14 + - clang-16 + BIN: [64] + CONF: + - GEN: Unix Makefiles + CONFIG: Debug + - GEN: Unix Makefiles + CONFIG: Release + - GEN: Ninja Multi-Config + CONFIG: Release + IMAGE: + - khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-22.04.20230717 + include: + - CMAKE: system + C_COMPILER: gcc-9 + BIN: 64 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + C_COMPILER: gcc-9 + BIN: 64 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + C_COMPILER: gcc-9 + BIN: 32 + CONF: + GEN: Unix Makefiles + CONFIG: Debug + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + - CMAKE: system + C_COMPILER: gcc-9 + BIN: 32 + CONF: + GEN: Unix Makefiles + CONFIG: Release + IMAGE: khronosgroup/docker-images:opencl-sdk-intelcpu-ubuntu-20.04.20230717 + container: ${{matrix.IMAGE}} + env: + CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake + CPACK_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cpack + CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest + CC: ${{matrix.C_COMPILER}} + CFLAGS: -Wall -Wextra -Werror -pedantic -m${{matrix.BIN}} + DEB_INSTALLATION_PATH: /usr + + steps: + - name: Install system CMake + if: ${{matrix.CMAKE}} == 'system' + run: apt-get update -qq && apt-get install -y cmake && + echo "CMAKE_EXE=cmake" >> "$GITHUB_ENV" && + echo "CPACK_EXE=cpack" >> "$GITHUB_ENV" && + echo "CTEST_EXE=ctest" >> "$GITHUB_ENV" + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + path: external/OpenCL-Headers + repository: KhronosGroup/OpenCL-Headers + + - name: Configure, install & package OpenCL-Headers + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH + -D BUILD_TESTING=OFF + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + $CMAKE_EXE + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + --parallel `nproc` && + $CPACK_EXE + --config "$GITHUB_WORKSPACE/external/OpenCL-Headers/build/CPackConfig.cmake" + -G DEB + -C ${{matrix.CONF.CONFIG}} + -B "$GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb" + + - name: Configure + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D BUILD_TESTING=ON + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D CPACK_PACKAGING_INSTALL_PREFIX=$DEB_INSTALLATION_PATH + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config ${{matrix.CONF.CONFIG}} --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release; + fi + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE --output-on-failure --no-tests=error -C Debug --parallel `nproc`; + $CTEST_EXE --output-on-failure --no-tests=error -C Release --parallel `nproc`; + fi + + - name: Package DEB + run: $CPACK_EXE + --config "$GITHUB_WORKSPACE/build/CPackConfig.cmake" + -G DEB + -C ${{matrix.CONF.CONFIG}} + -B "$GITHUB_WORKSPACE/package-deb" + + - name: Consume (DEB) + run: dpkg -i $GITHUB_WORKSPACE/external/OpenCL-Headers/package-deb/*.deb && + dpkg -i $GITHUB_WORKSPACE/package-deb/*.deb && + $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/`if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "libOpenCLDriverStub.so"; else echo "${{ matrix.CONF.CONFIG }}/libOpenCLDriverStub.so"; fi` + -S $GITHUB_WORKSPACE/test/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_package && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config ${{matrix.CONF.CONFIG}} --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_package --config Release; + fi + + - name: Run consume test (DEB) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build_package + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (DEB) + # We expect no pre-processor and compile flags (--cflags) but we do expect link flags (--libs) + run: if [[ $(pkg-config OpenCL --cflags) ]]; + then + exit 1; + fi && + pkg-config OpenCL --libs | grep -q "\-lOpenCL" + + - name: Test cllayerinfo (DEB) + run: cllayerinfo + + - name: Uninstall (DEB) + run: apt-get remove -y "khronos-opencl-loader*" opencl-c-headers + + - name: Test install + run: $CMAKE_EXE --build $GITHUB_WORKSPACE/build --target install --config ${{matrix.CONF.CONFIG}} --parallel `nproc` + + - name: Consume (install) + run: $CMAKE_EXE + -G "${{matrix.CONF.GEN}}" + `if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "-D CMAKE_BUILD_TYPE=${{matrix.CONF.CONFIG}}"; fi` + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/install;$GITHUB_WORKSPACE/external/OpenCL-Headers/install" + -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/`if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; then echo "libOpenCLDriverStub.so"; else echo "${{ matrix.CONF.CONFIG }}/libOpenCLDriverStub.so"; fi` + -S $GITHUB_WORKSPACE/test/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --parallel `nproc`; + else + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Debug; + $CMAKE_EXE --build $GITHUB_WORKSPACE/build_install --config Release; + fi + + - name: Run consume test (install) + if: matrix.BIN != 32 + working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build_install + run: if [[ "${{matrix.CONF.GEN}}" == "Unix Makefiles" ]]; + then + $CTEST_EXE -C ${{matrix.CONF.CONFIG}} --output-on-failure --no-tests=error --parallel `nproc`; + else + $CTEST_EXE -C Debug --output-on-failure --no-tests=error --parallel `nproc`; + $CTEST_EXE -C Release --output-on-failure --no-tests=error --parallel `nproc`; + fi + + - name: Test pkg-config (install) + # We expect no pre-processor and compile flags (--cflags) but we do expect link flags (--libs) + run: export PKG_CONFIG_PATH="$GITHUB_WORKSPACE/install/lib/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig" && + pkg-config OpenCL --cflags | grep -q "\-I$GITHUB_WORKSPACE/external/OpenCL-Headers/install/include" && + pkg-config OpenCL --libs | grep -q "\-L$GITHUB_WORKSPACE/install/lib \-lOpenCL" + + windows: + runs-on: windows-latest + defaults: + run: + shell: pwsh + strategy: + matrix: + VER: [v142, v143, clangcl] + GEN: [Visual Studio 17 2022, Ninja Multi-Config] + BIN: [x64] + exclude: + - VER: clangcl + GEN: Ninja Multi-Config + include: + - VER: v142 + GEN: Visual Studio 17 2022 + BIN: x86 + env: + NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip + NINJA_ROOT: C:\Tools\Ninja + VS_ROOT: 'C:\Program Files\Microsoft Visual Studio\2022\Enterprise' + UseMultiToolTask: true # Better parallel MSBuild execution + EnforceProcessCountAcrossBuilds: 'true' + MultiProcMaxCount: '3' + # C4152: nonstandard extension, function/data pointer conversion in expression + # C4201: nonstandard extension used: nameless struct/union + # C4310: cast truncates constant value + CFLAGS: /W4 /WX /wd4152 /wd4201 /wd4310 + + steps: + - name: Cache Ninja install + if: matrix.GEN == 'Ninja Multi-Config' + id: ninja-install + uses: actions/cache@v4 + with: + path: | + C:\Tools\Ninja + key: ${{runner.os}}-ninja-${{env.NINJA_URL}} + + - name: Install Ninja + if: matrix.GEN == 'Ninja Multi-Config' && steps.ninja-install.outputs.cache-hit != 'true' + run: | + Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip + Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath ${env:NINJA_ROOT}\ + Remove-Item ~\Downloads\* + + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Build & install OpenCL-Headers (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G "${{matrix.GEN}}" ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=OFF ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build" ` + --target install ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers failed." } + + - name: Build & install OpenCL-Headers (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G "${{matrix.GEN}}" ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=OFF ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers ` + -B ${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-Headers failed." } + & cmake ` + --build "${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\build" ` + --target install ` + -- ` + -j ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-Headers failed." } + + - name: Configure (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G "${{matrix.GEN}}" ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install ` + -D CMAKE_PREFIX_PATH=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE} ` + -B ${env:GITHUB_WORKSPACE}\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader failed." } + + - name: Configure (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G "${{matrix.GEN}}" ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D BUILD_TESTING=ON ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_INSTALL_PREFIX=${env:GITHUB_WORKSPACE}\install ` + -D CMAKE_PREFIX_PATH=${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install ` + -S ${env:GITHUB_WORKSPACE} ` + -B ${env:GITHUB_WORKSPACE}\build + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader failed." } + + - name: Build (MSBuild) + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config $Config ` + -- ` + /verbosity:minimal ` + /maxCpuCount ` + /noLogo + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader in $Config failed." } + } + + - name: Build (Ninja Multi-Config) + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config $Config ` + -- ` + -j ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader in $Config failed." } + } + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build + run: | + $REG = if('${{matrix.BIN}}' -eq 'x64') {"reg"} else {"${env:SystemRoot}\Syswow64\reg.exe"} + $KEY_NAME = "HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors" + foreach ($Config in 'Release','Debug') { + $VALUE_NAME = "${env:GITHUB_WORKSPACE}/build/$Config/OpenCLDriverStub.dll" + & $REG ADD $KEY_NAME /v $VALUE_NAME /t REG_DWORD /d 0 + & ctest -C $Config --output-on-failure --no-tests=error --parallel ${env:NUMBER_OF_PROCESSORS} + if ($LASTEXITCODE -ne 0) { throw "Testing OpenCL-ICD-Loader in $Config failed." } + & $REG DELETE $KEY_NAME /v $VALUE_NAME /f + } + + - name: Install + run: | + & cmake ` + --build "${env:GITHUB_WORKSPACE}\build" ` + --config Release ` + --target install + if ($LASTEXITCODE -ne 0) { throw "Installing OpenCL-ICD-Loader failed." } + + - name: "Consume (MSBuild standalone): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\install" ` + -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" ` + -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader standalone consume test failed." } + $REG = if('${{matrix.BIN}}' -eq 'x64') {"reg"} else {"${env:SystemRoot}\Syswow64\reg.exe"} + $KEY_NAME = "HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors" + $VALUE_NAME = "${env:GITHUB_WORKSPACE}/build/Release/OpenCLDriverStub.dll" + & $REG ADD $KEY_NAME /v $VALUE_NAME /t REG_DWORD /d 0 + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config $Config + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-ICD-Loader standalone consume test in $Config failed." } + } + & $REG DELETE $KEY_NAME /v $VALUE_NAME /f + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + + - name: "Consume (Ninja-Multi-Config standalone): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\install" ` + -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" ` + -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\bare" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader standalone consume test failed." } + $REG = if('${{matrix.BIN}}' -eq 'x64') {"reg"} else {"${env:SystemRoot}\Syswow64\reg.exe"} + $KEY_NAME = "HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors" + $VALUE_NAME = "${env:GITHUB_WORKSPACE}/build/Release/OpenCLDriverStub.dll" + & $REG ADD $KEY_NAME /v $VALUE_NAME /t REG_DWORD /d 0 + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare" ` + --config $Config + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader standalone consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\bare + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-ICD-Loader standalone consume test in $Config failed." } + } + & $REG DELETE $KEY_NAME /v $VALUE_NAME /f + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + + - name: Consume (Emulate SDK presence) + run: | + New-Item -Type Directory -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL + $workspace = ${env:GITHUB_WORKSPACE}.replace("\", "/") + New-Item -Type File -Path ${env:GITHUB_WORKSPACE}\install\share\cmake\OpenCL\OpenCLConfig.cmake -Value "include(`"$workspace/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake`")`r`ninclude(`"`${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake`")" + + - name: "Consume (MSBuild SDK): Configure/Build/Test" + if: matrix.GEN == 'Visual Studio 17 2022' + run: | + $BIN = if('${{matrix.BIN}}' -eq 'x86') {'Win32'} else {'x64'} + & cmake ` + -G '${{matrix.GEN}}' ` + -A $BIN ` + -T ${{matrix.VER}} ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\install" ` + -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" ` + -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader in-SDK consume test failed." } + $REG = if('${{matrix.BIN}}' -eq 'x64') {"reg"} else {"${env:SystemRoot}\Syswow64\reg.exe"} + $KEY_NAME = "HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors" + $VALUE_NAME = "${env:GITHUB_WORKSPACE}/build/Release/OpenCLDriverStub.dll" + & $REG ADD $KEY_NAME /v $VALUE_NAME /t REG_DWORD /d 0 + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config $Config + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-ICD-Loader in-SDK consume test in $Config failed." } + } + & $REG DELETE $KEY_NAME /v $VALUE_NAME /f + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + + - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" + if: matrix.GEN == 'Ninja Multi-Config' + run: | + $VER = switch ('${{matrix.VER}}') { ` + 'v142' {'14.2'} ` + 'v143' {'14.4'} } + Import-Module "${env:VS_ROOT}\Common7\Tools\Microsoft.VisualStudio.DevShell.dll" + Enter-VsDevShell -VsInstallPath ${env:VS_ROOT} -SkipAutomaticLocation -DevCmdArguments "-host_arch=x64 -arch=${{matrix.BIN}} -vcvars_ver=$VER" + & cmake ` + -G '${{matrix.GEN}}' ` + -D CMAKE_MAKE_PROGRAM="${env:NINJA_ROOT}\ninja.exe" ` + -D CMAKE_C_EXTENSIONS=OFF ` + -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL ` + -D CMAKE_PREFIX_PATH="${env:GITHUB_WORKSPACE}\external\OpenCL-Headers\install;${env:GITHUB_WORKSPACE}\install" ` + -D DRIVER_STUB_PATH="${env:GITHUB_WORKSPACE}\build\Release\OpenCLDriverStub.dll" ` + -S "${env:GITHUB_WORKSPACE}\test\pkgconfig\sdk" ` + -B "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" + if ($LASTEXITCODE -ne 0) { throw "Configuring OpenCL-ICD-Loader in-SDK consume test failed." } + $REG = if('${{matrix.BIN}}' -eq 'x64') {"reg"} else {"${env:SystemRoot}\Syswow64\reg.exe"} + $KEY_NAME = "HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors" + $VALUE_NAME = "${env:GITHUB_WORKSPACE}/build/Release/OpenCLDriverStub.dll" + & $REG ADD $KEY_NAME /v $VALUE_NAME /t REG_DWORD /d 0 + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + foreach ($Config in 'Release','Debug') { + & cmake ` + --build "${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk" ` + --config $Config + if ($LASTEXITCODE -ne 0) { throw "Building OpenCL-ICD-Loader in-SDK consume test in $Config failed." } + & cd ${env:GITHUB_WORKSPACE}\downstream\pkgconfig\sdk + & ctest --output-on-failure --no-tests=error -C $Config + if ($LASTEXITCODE -ne 0) { throw "Running OpenCL-ICD-Loader in-SDK consume test in $Config failed." } + } + & $REG DELETE $KEY_NAME /v $VALUE_NAME /f + if ($LASTEXITCODE -ne 0) { throw "Editing registry failed." } + + macos: + runs-on: macos-latest + defaults: + run: + shell: bash + strategy: + matrix: + C_COMPILER: + - /usr/bin/clang + # Disabled due to problems with __has_cpp_attribute + # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=114007 + # - gcc-11 + # Disabled due to problems with the __API_AVAILABLE macro + # - gcc-13 + GEN: + - Xcode + - Ninja Multi-Config + exclude: + # These entries are excluded, since XCode selects its own compiler + - C_COMPILER: gcc-11 + GEN: Xcode + - C_COMPILER: gcc-13 + GEN: Xcode + env: + CFLAGS: -Wall -Wextra -pedantic -Werror + CC: ${{ matrix.C_COMPILER }} + + steps: + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Create Build Environment + run: | + # Install Ninja only if it's the selected generator and it's not available. + if [[ "${{matrix.GEN}}" == "Ninja Multi-Config" && ! `which ninja` ]]; then brew install ninja; fi && + if [[ ! `which pkg-config` ]]; then brew install pkg-config; fi && + cmake --version + + - name: Build & install OpenCL-Headers + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=OFF + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + cmake + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + --config Release + --parallel `sysctl -n hw.logicalcpu` + + - name: Configure + run: cmake + -G "${{matrix.GEN}}" + -D BUILD_TESTING=ON + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install + -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: | + cmake --build $GITHUB_WORKSPACE/build --config Release --parallel `sysctl -n hw.logicalcpu` + cmake --build $GITHUB_WORKSPACE/build --config Debug --parallel `sysctl -n hw.logicalcpu` + + - name: Test + working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build + run: | + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + - name: Test install + run: | + cmake --build $GITHUB_WORKSPACE/build --config Release --target install + + - name: Consume (install) + run: cmake + -G "${{matrix.GEN}}" + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" + -S $GITHUB_WORKSPACE/test/pkgconfig/bare + -B $GITHUB_WORKSPACE/build_install && + cmake --build $GITHUB_WORKSPACE/build_install --config Release --parallel `sysctl -n hw.logicalcpu` && + cmake --build $GITHUB_WORKSPACE/build_install --config Debug --parallel `sysctl -n hw.logicalcpu` + + - name: Test pkg-config + run: | + export PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/lib/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig && + pkg-config OpenCL --cflags | grep -q "\-I$GITHUB_WORKSPACE/external/OpenCL-Headers/install/include" && + pkg-config OpenCL --libs | grep -q "\-L$GITHUB_WORKSPACE/install/lib -lOpenCL" + + - name: Consume pkg-config + run: export PKG_CONFIG_PATH=$GITHUB_WORKSPACE/install/lib/pkgconfig:$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/pkgconfig && + cmake + -G "${{matrix.GEN}}" + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install" + -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.dylib + -B $GITHUB_WORKSPACE/build/downstream/pkgconfig + -S $GITHUB_WORKSPACE/test/pkgconfig/pkgconfig && + cmake --build $GITHUB_WORKSPACE/build/downstream/pkgconfig --config Release --parallel `sysctl -n hw.logicalcpu` && + cmake --build $GITHUB_WORKSPACE/build/downstream/pkgconfig --config Debug --parallel `sysctl -n hw.logicalcpu` && + cd $GITHUB_WORKSPACE/build/downstream/pkgconfig && + ctest -C Release --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` && + ctest -C Debug --output-on-failure --no-tests=error --parallel `sysctl -n hw.logicalcpu` + + android: + runs-on: ubuntu-latest + defaults: + run: + shell: bash + strategy: + matrix: + ABI: + - arm64-v8a + - x86_64 + API_LEVEL: + - android-19 + - android-33 + CONFIG: + - Debug + - Release + env: + CFLAGS: -Wall -Wextra -pedantic -Werror + steps: + - name: Checkout OpenCL-ICD-Loader + uses: actions/checkout@v4 + + - name: Checkout OpenCL-Headers + uses: actions/checkout@v4 + with: + repository: KhronosGroup/OpenCL-Headers + path: external/OpenCL-Headers + + - name: Configure & install OpenCL-Headers + run: cmake + -G "Unix Makefiles" + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_C_EXTENSIONS=OFF + -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -D BUILD_TESTING=OFF + -S $GITHUB_WORKSPACE/external/OpenCL-Headers + -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build && + cmake + --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build + --target install + -- + -j`nproc` + + - name: Configure + run: cmake + -G "Unix Makefiles" + -D BUILD_TESTING=ON + -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} + -D CMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake + -D ANDROID_ABI=${{matrix.ABI}} + -D ANDROID_PLATFORM=${{matrix.API_LEVEL}} + -D CMAKE_FIND_ROOT_PATH_MODE_PACKAGE=ONLY + -D CMAKE_FIND_ROOT_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install + -S $GITHUB_WORKSPACE + -B $GITHUB_WORKSPACE/build + + - name: Build + run: cmake --build $GITHUB_WORKSPACE/build --parallel `nproc` diff --git a/deps/opencl-icd-loader/.github/workflows/release.yml b/deps/opencl-icd-loader/.github/workflows/release.yml new file mode 100644 index 000000000..06a8c2832 --- /dev/null +++ b/deps/opencl-icd-loader/.github/workflows/release.yml @@ -0,0 +1,74 @@ +name: Release + +on: + push: + tags: + - "v*" +env: + distroseries: jammy + +jobs: + release: + if: false + runs-on: ubuntu-latest + defaults: + run: + shell: bash + steps: + - name: Add PPA + run: sudo add-apt-repository -y ppa:${{ vars.PPA }} + + - name: Install prerequisites + run: sudo apt-get update -qq && sudo apt-get install -y cmake devscripts debhelper-compat=13 opencl-c-headers + + - name: Import GPG signing key + run: echo "${{ secrets.DEB_SIGNING_KEY }}" | gpg --import + + - name: Download and extract source code + run: | + wget -O $GITHUB_WORKSPACE/source.orig.tar.gz https://github.com/$GITHUB_REPOSITORY/archive/refs/tags/$GITHUB_REF_NAME.tar.gz + tar -xvf $GITHUB_WORKSPACE/source.orig.tar.gz + + - name: Configure project out-of-tree + run: cmake + -S $GITHUB_WORKSPACE/OpenCL-ICD-Loader* + -B $GITHUB_WORKSPACE/../build + -D CMAKE_BUILD_TYPE=Release + -D CMAKE_INSTALL_PREFIX=/usr + -D BUILD_TESTING=OFF + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D CPACK_DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + + - name: Generate packaging scripts + run: cmake + -D CMAKE_CACHE_PATH=$GITHUB_WORKSPACE/../build/CMakeCache.txt + -D ORIG_ARCHIVE=$GITHUB_WORKSPACE/source.orig.tar.gz + -D LATEST_RELEASE_VERSION=$GITHUB_REF_NAME + -D DEBIAN_DISTROSERIES=${{ env.distroseries }} + -D DEBIAN_PACKAGE_MAINTAINER="${{ vars.DEB_MAINTAINER }}" + -D DEBIAN_VERSION_SUFFIX=${{ vars.DEB_VERSION_SUFFIX }} + -P $GITHUB_WORKSPACE/OpenCL-ICD-Loader*/cmake/DebSourcePkg.cmake + + - name: Build source package + run: | + cd $GITHUB_WORKSPACE/OpenCL-ICD-Loader*/ + debuild -S -sa + + - name: Build binary package + run: cpack + -G DEB + -C Release + -B $GITHUB_WORKSPACE/../build + --config $GITHUB_WORKSPACE/../build/CPackConfig.cmake + + # The following step does not depend on the previous step "Build binary package", + # but if the binary package build is unsuccessful, it is better not to push the + # source packages to the PPA + - name: Push source package to the PPA + run: dput ppa:${{ vars.PPA }} $GITHUB_WORKSPACE/*source.changes + + - name: Create GitHub release + uses: softprops/action-gh-release@v1 + with: + files: ${{ github.workspace }}/../build/*.deb diff --git a/deps/opencl-icd-loader/.github/workflows/windows.yml b/deps/opencl-icd-loader/.github/workflows/windows.yml deleted file mode 100644 index f084fa5ad..000000000 --- a/deps/opencl-icd-loader/.github/workflows/windows.yml +++ /dev/null @@ -1,194 +0,0 @@ -name: Windows - -on: [push, pull_request] - -jobs: - msvc: - runs-on: windows-2022 - strategy: - matrix: - VER: [v141, v142, v143] - EXT: [ON, OFF] - GEN: [Visual Studio 17 2022, Ninja Multi-Config] - BIN: [x64, x86] - STD: [90, 11, 17] - CMAKE: [3.22.0] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{matrix.CMAKE}}/cmake-${{matrix.CMAKE}}-windows-x86_64.zip - CMAKE_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\cmake.exe - CTEST_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\ctest.exe - NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v1.10.2/ninja-win.zip - NINJA_EXE: C:\Tools\Ninja\ninja.exe - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v2 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v2 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Create Build Environment - shell: pwsh - run: | - Invoke-WebRequest ${env:CMAKE_URL} -OutFile ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip - Expand-Archive ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip -DestinationPath C:\Tools\Kitware\CMake\ - Rename-Item C:\Tools\Kitware\CMake\* ${{matrix.CMAKE}} - Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip - Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath C:\Tools\Ninja\ - Remove-Item ~\Downloads\* - & ${env:CMAKE_EXE} --version - & ${env:NINJA_EXE} --version - - - name: Build & install OpenCL-Headers (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - set C_FLAGS="/W4 /WX" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install --config Release -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build & install OpenCL-Headers (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - set C_FLAGS="/W4 /WX" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install -- -j%NUMBER_OF_PROCESSORS% - - - name: Configure (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Configure (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Build (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release -- /verbosity:minimal /maxCpuCount /noLogo - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - if /I "${{matrix.VER}}"=="v140" set VER=14.0 - if /I "${{matrix.VER}}"=="v141" set VER=14.1 - if /I "${{matrix.VER}}"=="v142" set VER=14.2 - if /I "${{matrix.VER}}"=="v143" set VER=14.3 - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: cmd - run: | - if /I "${{matrix.BIN}}"=="x64" set REG=reg - if /I "${{matrix.BIN}}"=="x86" set REG=%systemroot%\Syswow64\reg.exe - %REG% ADD HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll /t REG_DWORD /d 0 - %CTEST_EXE% -C Release --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - if errorlevel 1 ( - exit /b %errorlevel% - ) - %REG% DELETE HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll /f - %REG% ADD HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Debug/OpenCLDriverStub.dll /t REG_DWORD /d 0 - %CTEST_EXE% -C Debug --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - if errorlevel 1 ( - exit /b %errorlevel% - ) - %REG% DELETE HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Debug/OpenCLDriverStub.dll /f - - - name: Install - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/build --config Release --target install - - - name: "Consume (MSBuild standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (MSBuild SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug diff --git a/deps/opencl-icd-loader/.gitignore b/deps/opencl-icd-loader/.gitignore index 9bb7c139d..8a9dc7012 100644 --- a/deps/opencl-icd-loader/.gitignore +++ b/deps/opencl-icd-loader/.gitignore @@ -1,4 +1,22 @@ +# Build dir +[Bb]uild/ + +# Install dir +[Ii]nstall/ + +# External dir +[Ee]xternal/ + +# Package dir +[Pp]ackage[-_\s\d]*/ + +# Tackage dir +[T]esting/ + +# inc subdirs inc/CL/ inc/EGL/ inc/KHR/ -build/ + +# Visual Studio Code +.vscode diff --git a/deps/opencl-icd-loader/CMakeLists.txt b/deps/opencl-icd-loader/CMakeLists.txt index 07a4530a8..a1617d0fa 100644 --- a/deps/opencl-icd-loader/CMakeLists.txt +++ b/deps/opencl-icd-loader/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required (VERSION 3.1) +cmake_minimum_required (VERSION 3.16) # Include guard for including this project multiple times if(TARGET OpenCL) @@ -6,7 +6,7 @@ if(TARGET OpenCL) endif() project (OpenCL-ICD-Loader - VERSION 1.2 + VERSION 3.0 LANGUAGES C) find_package (Threads REQUIRED) @@ -46,14 +46,22 @@ if(DEFINED BUILD_SHARED_LIBS) else() set(OPENCL_ICD_LOADER_BUILD_SHARED_LIBS_DEFAULT ON) endif() - option(OPENCL_ICD_LOADER_BUILD_SHARED_LIBS "Build OpenCL ICD Loader as shared library" ${OPENCL_ICD_LOADER_BUILD_SHARED_LIBS_DEFAULT}) +option(OPENCL_ICD_LOADER_BUILD_SHARED_LIBS "Build OpenCL ICD Loader as shared library" ${OPENCL_ICD_LOADER_BUILD_SHARED_LIBS_DEFAULT}) # This option enables/disables support for OpenCL layers in the ICD loader. # It is currently needed default while the specification is being formalized, # and to study the performance impact. option (ENABLE_OPENCL_LAYERS "Enable OpenCL Layers" ON) +include(CMakeDependentOption) +cmake_dependent_option(ENABLE_OPENCL_LAYERINFO "Enable building cllayerinfo tool" ON ENABLE_OPENCL_LAYERS OFF) +include(GNUInstallDirs) + +set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") include(CheckFunctionExists) +include(JoinPaths) +include(Package) + check_function_exists(secure_getenv HAVE_SECURE_GETENV) check_function_exists(__secure_getenv HAVE___SECURE_GETENV) configure_file(${CMAKE_CURRENT_SOURCE_DIR}/loader/icd_cmake_config.h.in @@ -62,6 +70,7 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/loader/icd_cmake_config.h.in set (OPENCL_ICD_LOADER_SOURCES loader/icd.c loader/icd.h + loader/icd_version.h loader/icd_dispatch.c loader/icd_dispatch.h loader/icd_dispatch_generated.c @@ -69,7 +78,6 @@ set (OPENCL_ICD_LOADER_SOURCES loader/icd_platform.h) if (WIN32) - enable_language (CXX) list (APPEND OPENCL_ICD_LOADER_SOURCES loader/windows/adapter.h loader/windows/icd_windows.c @@ -79,9 +87,8 @@ if (WIN32) loader/windows/icd_windows_envvars.c loader/windows/icd_windows_hkr.c loader/windows/icd_windows_hkr.h - loader/windows/icd_windows_apppackage.cpp + loader/windows/icd_windows_apppackage.c loader/windows/icd_windows_apppackage.h - loader/windows/OpenCL.def loader/windows/OpenCL.rc) # Only add the DXSDK include directory if the environment variable is # defined. Since the DXSDK has merged into the Windows SDK, this is @@ -89,6 +96,14 @@ if (WIN32) if (DEFINED ENV{DXSDK_DIR} AND NOT (MINGW OR MSYS OR CYGWIN)) include_directories ($ENV{DXSDK_DIR}/Include) endif () + + # For mingw-i686 builds only we need a special .def file with stdcall + # exports. In all other cases we can use a standard .def file. + if ((CMAKE_SIZEOF_VOID_P EQUAL 4) AND (MINGW OR MSYS OR CYGWIN)) + list (APPEND OPENCL_ICD_LOADER_SOURCES loader/windows/OpenCL-mingw-i686.def) + else () + list (APPEND OPENCL_ICD_LOADER_SOURCES loader/windows/OpenCL.def) + endif () else () list (APPEND OPENCL_ICD_LOADER_SOURCES loader/linux/icd_linux.c @@ -106,17 +121,17 @@ endif() add_library (OpenCL::OpenCL ALIAS OpenCL) -set_target_properties (OpenCL PROPERTIES VERSION "1.2" SOVERSION "1") +set_target_properties (OpenCL PROPERTIES VERSION 1\.0\.0 SOVERSION "1") if (WIN32) target_link_libraries (OpenCL PRIVATE cfgmgr32.lib runtimeobject.lib) - option (OPENCL_ICD_LOADER_DISABLE_OPENCLON12 "Disable support for OpenCLOn12. Support for OpenCLOn12 should only be disabled when building an import lib to link with, and must be enabled when building an ICD loader for distribution!" OFF) + # Generate a DLL without a "lib" prefix for mingw. + if (MINGW OR MSYS OR CYGWIN) + set_target_properties(OpenCL PROPERTIES PREFIX "") + set_target_properties(OpenCL PROPERTIES LINK_FLAGS "-Wl,-disable-stdcall-fixup") + endif() else() - # Force -fPIC on linux/mac, since we link static library with dynamic - # to avoid `relocation R_X86_64_PC32 against symbol...` errors - target_compile_options (OpenCL PRIVATE "-fPIC") - target_link_libraries (OpenCL PRIVATE ${CMAKE_THREAD_LIBS_INIT}) if (NOT APPLE) set_target_properties (OpenCL PROPERTIES LINK_FLAGS "-Wl,--version-script -Wl,${CMAKE_CURRENT_SOURCE_DIR}/loader/linux/icd_exports.map") @@ -139,11 +154,18 @@ else () target_link_libraries (OpenCL PUBLIC OpenCL::Headers) endif () -target_compile_definitions (OpenCL - PRIVATE +set (OPENCL_COMPILE_DEFINITIONS CL_TARGET_OPENCL_VERSION=300 + CL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES + OPENCL_ICD_LOADER_VERSION_MAJOR=3 + OPENCL_ICD_LOADER_VERSION_MINOR=0 + OPENCL_ICD_LOADER_VERSION_REV=6 $<$:CL_ENABLE_LAYERS> - $<$:OPENCL_ICD_LOADER_DISABLE_OPENCLON12> +) + +target_compile_definitions (OpenCL + PRIVATE + ${OPENCL_COMPILE_DEFINITIONS} ) target_include_directories (OpenCL @@ -153,6 +175,44 @@ target_include_directories (OpenCL ) target_link_libraries (OpenCL PUBLIC ${CMAKE_DL_LIBS}) +if (ENABLE_OPENCL_LAYERINFO) + + set (OPENCL_LAYER_INFO_SOURCES + loader/cllayerinfo.c + ${OPENCL_ICD_LOADER_SOURCES} + ) + + add_executable(cllayerinfo ${OPENCL_LAYER_INFO_SOURCES}) + + add_executable(OpenCL::cllayerinfo ALIAS cllayerinfo) + + target_compile_definitions (cllayerinfo + PRIVATE + CL_LAYER_INFO + ${OPENCL_COMPILE_DEFINITIONS} + ) + + if (EXISTS ${OPENCL_ICD_LOADER_HEADERS_DIR}/CL/cl.h) + target_include_directories (cllayerinfo PUBLIC $) + else () + target_link_libraries (cllayerinfo PUBLIC OpenCL::Headers) + endif () + + if (WIN32) + target_link_libraries (cllayerinfo PRIVATE cfgmgr32.lib runtimeobject.lib) + else () + target_link_libraries (cllayerinfo PRIVATE ${CMAKE_THREAD_LIBS_INIT}) + endif () + + target_link_libraries (cllayerinfo PUBLIC ${CMAKE_DL_LIBS}) + + target_include_directories (cllayerinfo + PRIVATE + ${CMAKE_CURRENT_BINARY_DIR} + loader + ) +endif () + option (OPENCL_ICD_LOADER_BUILD_TESTING "Enable support for OpenCL ICD Loader testing." OFF) if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_ICD_LOADER_BUILD_TESTING) @@ -162,13 +222,11 @@ if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_ICD_LOADER_BUILD_TESTING) add_subdirectory (test) endif() -include (GNUInstallDirs) - install( TARGETS OpenCL EXPORT OpenCLICDLoaderTargets LIBRARY - DESTINATION ${CMAKE_INSTALL_LIBDIR} # obtained from GNUInstallDirs + DESTINATION ${CMAKE_INSTALL_LIBDIR} # obtained from GNUInstallDirs ) install( # FILES $ is cleanest, but is MSVC link.exe specific. LLVM's lld.exe and lld-link.exe don't support it (configure-time error) @@ -178,6 +236,15 @@ install( OPTIONAL ) +if (ENABLE_OPENCL_LAYERINFO) + install( + TARGETS cllayerinfo + RUNTIME + DESTINATION ${CMAKE_INSTALL_BINDIR} + COMPONENT cllayerinfo + ) +endif() + export( EXPORT OpenCLICDLoaderTargets FILE ${PROJECT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake @@ -194,10 +261,12 @@ install( FILE OpenCLICDLoaderTargets.cmake NAMESPACE OpenCL:: DESTINATION ${config_package_location} + COMPONENT dev ) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfig.cmake DESTINATION ${config_package_location} + COMPONENT dev ) unset(CMAKE_SIZEOF_VOID_P) @@ -210,9 +279,18 @@ write_basic_package_version_file( install( FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfigVersion.cmake DESTINATION ${config_package_location} + COMPONENT dev ) +# Separate namelink from shared library and symlink for DEB packaging +install (TARGETS OpenCL + LIBRARY + DESTINATION ${CMAKE_INSTALL_LIBDIR} + COMPONENT runtime + NAMELINK_SKIP) + install (TARGETS OpenCL - RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} - ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} - LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) + LIBRARY + DESTINATION ${CMAKE_INSTALL_LIBDIR} + COMPONENT dev + NAMELINK_ONLY) diff --git a/deps/opencl-icd-loader/OpenCL.pc.in b/deps/opencl-icd-loader/OpenCL.pc.in new file mode 100644 index 000000000..ef3533362 --- /dev/null +++ b/deps/opencl-icd-loader/OpenCL.pc.in @@ -0,0 +1,9 @@ +prefix=@PKGCONFIG_PREFIX@ +exec_prefix=${prefix} +libdir=@OPENCL_LIBDIR_PC@ + +Name: OpenCL +Description: Khronos OpenCL ICD Loader +Requires: OpenCL-Headers +Version: 3.0 +Libs: -L${libdir} -lOpenCL diff --git a/deps/opencl-icd-loader/README.md b/deps/opencl-icd-loader/README.md index 1757b5250..a7aa86521 100644 --- a/deps/opencl-icd-loader/README.md +++ b/deps/opencl-icd-loader/README.md @@ -35,9 +35,6 @@ The OpenCL ICD Loader requires: - It is recommended to install the headers via CMake, however a convenience shorthand is provided. Providing `OPENCL_ICD_LOADER_HEADERS_DIR` to CMake, one may specify the location of OpenCL Headers. By default, the OpenCL ICD Loader will look for OpenCL Headers in the inc directory. - The OpenCL ICD Loader uses CMake for its build system. If CMake is not provided by your build system or OS package manager, please consult the [CMake website](https://cmake.org). -- The Windows OpenCL ICD Loader requires the Windows SDK to check for and enumerate the OpenCLOn12 ICD. -An OpenCL ICD Loader can be built without a dependency on the Windows SDK using the CMake variable `OPENCL_ICD_LOADER_DISABLE_OPENCLON12`. -This variable should only be used when building an import lib to link with, and must be enabled when building an OpenCL ICD Loader for distribution! ### Example Build @@ -147,5 +144,6 @@ The following debug environment variables are available for use with the OpenCL |:---------------------------------:|---------------------|----------------------| | OCL_ICD_FILENAMES | Specifies a list of additional ICDs to load. The ICDs will be enumerated first, before any ICDs discovered via default mechanisms. | `export OCL_ICD_FILENAMES=libVendorA.so:libVendorB.so`

`set OCL_ICD_FILENAMES=vendor_a.dll;vendor_b.dll` | | OCL_ICD_VENDORS | On Linux and Android, specifies a directory to scan for ICDs to enumerate in place of the default `/etc/OpenCL/vendors'. | `export OCL_ICD_VENDORS=/my/local/icd/search/path` | -| OPENCL_LAYERS | Specifies a list of layers to load. | `export OPENCL_LAYERS=libLayerA.so:libLayerB.so`

`set OPENCL_LAYERS=libLayerA.dll;libLayerB.dll` | -| OCL_ICD_ENABLE_TRACE | Enable the trace mechanism | `export OCL_ICD_ENABLE_TRACE=True`

`set OCL_ICD_ENABLE_TRACE=True`
`true, T, 1 can also be used here.` | +| OPENCL_LAYERS | Specifies a list of layers to load. | `export OPENCL_LAYERS=libLayerA.so:libLayerB.so`

`set OPENCL_LAYERS=libLayerA.dll;libLayerB.dll` | +| OPENCL_LAYER_PATH | On Linux and Android, specifies a directory to scan for layers to enumerate in place of the default `/etc/OpenCL/layers'. | `export OPENCL_LAYER_PATH=/my/local/layers/search/path` | +| OCL_ICD_ENABLE_TRACE | Enable the trace mechanism | `export OCL_ICD_ENABLE_TRACE=True`

`set OCL_ICD_ENABLE_TRACE=True`
`true, T, 1 can also be used here.` | diff --git a/deps/opencl-icd-loader/cmake/DebSourcePkg.cmake b/deps/opencl-icd-loader/cmake/DebSourcePkg.cmake new file mode 100644 index 000000000..eb10e6a06 --- /dev/null +++ b/deps/opencl-icd-loader/cmake/DebSourcePkg.cmake @@ -0,0 +1,160 @@ +# This script produces the changelog, control and rules file in the debian +# directory. These files are needed to build a Debian source package from the repository. +# Run this in CMake script mode, e.g. +# $ cd OpenCL-ICD-Loader +# $ cmake -S . -B ../build -D BUILD_TESTING=OFF +# $ cmake +# -DCMAKE_CACHE_PATH=../build/CMakeCache.txt +# -DCPACK_DEBIAN_PACKAGE_MAINTAINER="Example Name " +# -DDEBIAN_DISTROSERIES=jammy +# -DORIG_ARCHIVE=../OpenCL-ICD-Loader.tar.gz +# -DLATEST_RELEASE_VERSION=v2023.08.29 +# -P cmake/DebSourcePkg.cmake +# $ debuild -S -sa + +cmake_minimum_required(VERSION 3.21) # file(COPY_FILE) is added in CMake 3.21 + +if(NOT EXISTS "${CMAKE_CACHE_PATH}") + message(FATAL_ERROR "CMAKE_CACHE_PATH is not set or does not exist") +endif() +if(NOT DEFINED DEBIAN_PACKAGE_MAINTAINER) + message(FATAL_ERROR "DEBIAN_PACKAGE_MAINTAINER is not set") +endif() +if(NOT DEFINED DEBIAN_DISTROSERIES) + message(FATAL_ERROR "DEBIAN_DISTROSERIES is not set") +endif() +if(NOT DEFINED ORIG_ARCHIVE) + message(WARNING "ORIG_ARCHIVE is not set") +elseif(NOT EXISTS "${ORIG_ARCHIVE}") + message(FATAL_ERROR "ORIG_ARCHIVE is defined, but the file does not exist at \"${ORIG_ARCHIVE}\"") +endif() +if(NOT DEFINED LATEST_RELEASE_VERSION) + message(WARNING "LATEST_RELEASE_VERSION is not set") +endif() +if(NOT DEFINED DEBIAN_VERSION_SUFFIX) + message(WARNING "DEBIAN_VERSION_SUFFIX is not set") +endif() + +# Extracting the project version from the main CMakeLists.txt via regex +file(READ "${CMAKE_CACHE_PATH}" CMAKE_CACHE) +string(REGEX MATCH "CMAKE_PROJECT_VERSION[^=]*=([^\n]*)" REGEX_MATCH "${CMAKE_CACHE}") +if(NOT REGEX_MATCH) + message(FATAL_ERROR "Could not extract project version from CMakeLists.txt") +endif() +set(PROJECT_VERSION "${CMAKE_MATCH_1}") + +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}") +# Package.cmake contains all details for packaging +include(PackageSetup) + +# Append a space after every newline in the description. This format is required +# in the control file. +string(REPLACE "\n" "\n " CPACK_DEBIAN_DEV_DESCRIPTION "${CPACK_DEBIAN_DEV_DESCRIPTION}") +string(REPLACE "\n" "\n " CPACK_DEBIAN_RUNTIME_DESCRIPTION "${CPACK_DEBIAN_RUNTIME_DESCRIPTION}") +string(REPLACE "\n" "\n " CPACK_DEBIAN_CLLAYERINFO_DESCRIPTION "${CPACK_DEBIAN_CLLAYERINFO_DESCRIPTION}") + +set(DEB_SOURCE_PKG_DIR "${CMAKE_CURRENT_LIST_DIR}/../debian") +# Write debian/control +file(WRITE "${DEB_SOURCE_PKG_DIR}/control" +"Source: ${PACKAGE_NAME_PREFIX} +Section: ${CPACK_DEBIAN_DEV_PACKAGE_SECTION} +Priority: optional +Maintainer: ${DEBIAN_PACKAGE_MAINTAINER} +Build-Depends: cmake, debhelper-compat (=13), opencl-c-headers +Rules-Requires-Root: no +Homepage: ${CPACK_DEBIAN_PACKAGE_HOMEPAGE} +Standards-Version: 4.6.2 + +Package: ${CPACK_DEBIAN_DEV_PACKAGE_NAME} +Architecture: any +Multi-Arch: same +Depends: ${CPACK_DEBIAN_DEV_PACKAGE_DEPENDS}, ${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME} (=${PACKAGE_VERSION_REVISION}) +Recommends: ${CPACK_DEBIAN_DEV_PACKAGE_RECOMMENDS} +Conflicts: ${CPACK_DEBIAN_DEV_PACKAGE_CONFLICTS} +Breaks: ${CPACK_DEBIAN_DEV_PACKAGE_BREAKS} +Replaces: ${CPACK_DEBIAN_DEV_PACKAGE_REPLACES} +Provides: ${CPACK_DEBIAN_DEV_PACKAGE_PROVIDES} +Description: ${CPACK_DEBIAN_DEV_DESCRIPTION} + +Package: ${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME} +Section: ${CPACK_DEBIAN_RUNTIME_PACKAGE_SECTION} +Architecture: any +Multi-Arch: same +Depends: ${CPACK_DEBIAN_RUNTIME_PACKAGE_DEPENDS} +# Conflicts and replaces deliberately not added +# The runtime package provides libOpenCL.so.1.0.0 and libOpenCL.so.1 via update-alternatives +# Conflicts: ${CPACK_DEBIAN_RUNTIME_PACKAGE_CONFLICTS} +# Replaces: ${CPACK_DEBIAN_RUNTIME_PACKAGE_REPLACES} +Provides: ${CPACK_DEBIAN_RUNTIME_PACKAGE_PROVIDES} +Description: ${CPACK_DEBIAN_RUNTIME_DESCRIPTION} + +Package: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_NAME} +Section: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_SECTION} +Architecture: any +Depends: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_DEPENDS}, ${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME} (=${PACKAGE_VERSION_REVISION}) +Conflicts: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_CONFLICTS} +Replaces: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_REPLACES} +Provides: ${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_PROVIDES} +Description: ${CPACK_DEBIAN_CLLAYERINFO_DESCRIPTION} +" +) +# Write debian/changelog +string(TIMESTAMP CURRENT_TIMESTAMP "%a, %d %b %Y %H:%M:%S +0000" UTC) +file(WRITE "${DEB_SOURCE_PKG_DIR}/changelog" +"${PACKAGE_NAME_PREFIX} (${PACKAGE_VERSION_REVISION}) ${DEBIAN_DISTROSERIES}; urgency=medium + + * Released version ${PACKAGE_VERSION_REVISION} + + -- ${DEBIAN_PACKAGE_MAINTAINER} ${CURRENT_TIMESTAMP} +") +# Write debian/rules +file(WRITE "${DEB_SOURCE_PKG_DIR}/rules" +"#!/usr/bin/make -f +%: +\tdh $@ + +override_dh_auto_configure: +\tdh_auto_configure -- -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTING=OFF + +GENERATED_MAINTAINER_SCRIPTS := $(patsubst %.in,%,$(wildcard debian/*.alternatives.in)) + +$(GENERATED_MAINTAINER_SCRIPTS): %: %.in +\tsed \"s%@DEB_HOST_MULTIARCH@%$(DEB_HOST_MULTIARCH)%g\" < $< > $@ + +execute_before_dh_install: $(GENERATED_MAINTAINER_SCRIPTS) +\ttrue # An empty rule would confuse dh +") +file(WRITE "${DEB_SOURCE_PKG_DIR}/${CPACK_DEBIAN_DEV_PACKAGE_NAME}.install" +"usr/lib/*/pkgconfig +usr/lib/*/lib*.so +usr/share +") +# The .so files are installed to a different directory, and then linked back +# the the original location via update-alternatives. +file(WRITE "${DEB_SOURCE_PKG_DIR}/${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME}.install" +"usr/lib/*/lib*.so.* usr/lib/\${DEB_HOST_MULTIARCH}/KhronosOpenCLICDLoader +") +file(WRITE "${DEB_SOURCE_PKG_DIR}/${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME}.alternatives.in" +"Name: libOpenCL.so.1.0.0-@DEB_HOST_MULTIARCH@ +Link: /usr/lib/@DEB_HOST_MULTIARCH@/libOpenCL.so.1.0.0 +Alternative: /usr/lib/@DEB_HOST_MULTIARCH@/KhronosOpenCLICDLoader/libOpenCL.so.1.0.0 +Dependents: + /usr/lib/@DEB_HOST_MULTIARCH@/libOpenCL.so.1 libOpenCL.so.1-@DEB_HOST_MULTIARCH@ /usr/lib/@DEB_HOST_MULTIARCH@/KhronosOpenCLICDLoader/libOpenCL.so.1 +Priority: 100 +") +file(WRITE "${DEB_SOURCE_PKG_DIR}/${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_NAME}.install" +"usr/bin +") + +if(DEFINED ORIG_ARCHIVE) + # Copy the passed orig.tar.gz file. The target filename is deduced from the version number, as expected by debuild + cmake_path(IS_ABSOLUTE ORIG_ARCHIVE IS_ORIG_ARCHIVE_ABSOLUTE) + if (NOT IS_ORIG_ARCHIVE_ABSOLUTE) + message(FATAL_ERROR "ORIG_ARCHIVE must be an absolute path (passed: \"${ORIG_ARCHIVE}\")") + endif() + cmake_path(GET ORIG_ARCHIVE EXTENSION ORIG_ARCHIVE_EXT) + cmake_path(GET ORIG_ARCHIVE PARENT_PATH ORIG_ARCHIVE_PARENT) + set(TARGET_PATH "${ORIG_ARCHIVE_PARENT}/${PACKAGE_NAME_PREFIX}_${CPACK_DEBIAN_PACKAGE_VERSION}${ORIG_ARCHIVE_EXT}") + message(STATUS "Copying \"${ORIG_ARCHIVE}\" to \"${TARGET_PATH}\"") + file(COPY_FILE "${ORIG_ARCHIVE}" "${TARGET_PATH}") +endif() diff --git a/deps/opencl-icd-loader/cmake/JoinPaths.cmake b/deps/opencl-icd-loader/cmake/JoinPaths.cmake new file mode 100644 index 000000000..32d6d6685 --- /dev/null +++ b/deps/opencl-icd-loader/cmake/JoinPaths.cmake @@ -0,0 +1,26 @@ +# This module provides function for joining paths +# known from from most languages +# +# Original license: +# SPDX-License-Identifier: (MIT OR CC0-1.0) +# Explicit permission given to distribute this module under +# the terms of the project as described in /LICENSE.rst. +# Copyright 2020 Jan Tojnar +# https://github.com/jtojnar/cmake-snips +# +# Modelled after Python’s os.path.join +# https://docs.python.org/3.7/library/os.path.html#os.path.join +# Windows not supported +function(join_paths joined_path first_path_segment) + set(temp_path "${first_path_segment}") + foreach(current_segment IN LISTS ARGN) + if(NOT ("${current_segment}" STREQUAL "")) + if(IS_ABSOLUTE "${current_segment}") + set(temp_path "${current_segment}") + else() + set(temp_path "${temp_path}/${current_segment}") + endif() + endif() + endforeach() + set(${joined_path} "${temp_path}" PARENT_SCOPE) +endfunction() diff --git a/deps/opencl-icd-loader/cmake/Package.cmake b/deps/opencl-icd-loader/cmake/Package.cmake new file mode 100644 index 000000000..adfa50561 --- /dev/null +++ b/deps/opencl-icd-loader/cmake/Package.cmake @@ -0,0 +1,40 @@ +include("${CMAKE_CURRENT_LIST_DIR}/PackageSetup.cmake") + +# Configuring pkgconfig + +# We need two different instances of OpenCL.pc +# One for installing (cmake --install), which contains CMAKE_INSTALL_PREFIX as prefix +# And another for the Debian development package, which contains CPACK_PACKAGING_INSTALL_PREFIX as prefix + +join_paths(OPENCL_INCLUDEDIR_PC "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") +join_paths(OPENCL_LIBDIR_PC "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}") + +set(pkg_config_location ${CMAKE_INSTALL_LIBDIR}/pkgconfig) +set(PKGCONFIG_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Configure and install OpenCL.pc for installing the project +configure_file( + OpenCL.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL.pc + @ONLY) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_install/OpenCL.pc + DESTINATION ${pkg_config_location} + COMPONENT pkgconfig_install) + +# Configure and install OpenCL.pc for the Debian package +set(PKGCONFIG_PREFIX "${CPACK_PACKAGING_INSTALL_PREFIX}") +configure_file( + OpenCL.pc.in + ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL.pc + @ONLY) + +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig_package/OpenCL.pc + DESTINATION ${pkg_config_location} + COMPONENT dev + EXCLUDE_FROM_ALL) + +set(CPACK_DEBIAN_PACKAGE_DEBUG ON) + +include(CPack) diff --git a/deps/opencl-icd-loader/cmake/PackageSetup.cmake b/deps/opencl-icd-loader/cmake/PackageSetup.cmake new file mode 100644 index 000000000..b4aade8a4 --- /dev/null +++ b/deps/opencl-icd-loader/cmake/PackageSetup.cmake @@ -0,0 +1,112 @@ +set(CPACK_PACKAGE_VENDOR "khronos") + +set(CPACK_DEBIAN_RUNTIME_DESCRIPTION "Generic OpenCL ICD Loader +OpenCL (Open Computing Language) is a multivendor open standard for +general-purpose parallel programming of heterogeneous systems that include +CPUs, GPUs and other processors. +. +This package contains an installable client driver loader (ICD Loader) +library that can be used to load any (free or non-free) installable client +driver (ICD) for OpenCL. It acts as a demultiplexer so several ICD can +be installed and used together.") + +set(CPACK_DEBIAN_DEV_DESCRIPTION "OpenCL development files +OpenCL (Open Computing Language) is a multivendor open standard for +general-purpose parallel programming of heterogeneous systems that include +CPUs, GPUs and other processors. +. +This package provides the development files: headers and libraries. +. +It also ensures that the ocl-icd ICD loader is installed so its additional +features (compared to the OpenCL norm) can be used: .pc file, ability to +select an ICD without root privilege, etc.") + +set(CPACK_DEBIAN_CLLAYERINFO_DESCRIPTION "Query OpenCL Layer system information +OpenCL (Open Computing Language) is a multivendor open standard for +general-purpose parallel programming of heterogeneous systems that include +CPUs, GPUs and other processors. It supports system and user configured layers +to intercept OpenCL API calls. +. +This package contains a tool that lists the layers loaded by the the ocl-icd +OpenCL ICD Loader.") + +set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE") + +set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md") + +if(NOT CPACK_PACKAGING_INSTALL_PREFIX) + set(CPACK_PACKAGING_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") +endif() + +# DEB packaging configuration +set(CPACK_DEBIAN_PACKAGE_MAINTAINER ${CPACK_PACKAGE_VENDOR}) + +set(CPACK_DEBIAN_PACKAGE_HOMEPAGE + "https://github.com/KhronosGroup/OpenCL-ICD-Loader") + +# Version number [epoch:]upstream_version[-debian_revision] +set(CPACK_DEBIAN_PACKAGE_VERSION "${PROJECT_VERSION}") # upstream_version +if(DEFINED LATEST_RELEASE_VERSION) + # Remove leading "v", if exists + string(LENGTH "${LATEST_RELEASE_VERSION}" LATEST_RELEASE_VERSION_LENGTH) + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 0 1 LATEST_RELEASE_VERSION_FRONT) + if(LATEST_RELEASE_VERSION_FRONT STREQUAL "v") + string(SUBSTRING "${LATEST_RELEASE_VERSION}" 1 ${LATEST_RELEASE_VERSION_LENGTH} LATEST_RELEASE_VERSION) + endif() + + string(APPEND CPACK_DEBIAN_PACKAGE_VERSION "~${LATEST_RELEASE_VERSION}") +endif() +set(CPACK_DEBIAN_PACKAGE_RELEASE "1") # debian_revision (because this is a + # non-native pkg) +set(PACKAGE_VERSION_REVISION "${CPACK_DEBIAN_PACKAGE_VERSION}-${CPACK_DEBIAN_PACKAGE_RELEASE}${DEBIAN_VERSION_SUFFIX}") + +# Get architecture +execute_process(COMMAND dpkg "--print-architecture" OUTPUT_VARIABLE CPACK_DEBIAN_PACKAGE_ARCHITECTURE) +string(STRIP "${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}" CPACK_DEBIAN_PACKAGE_ARCHITECTURE) + +########################################################## +# Components # +########################################################## + +set(CPACK_DEB_COMPONENT_INSTALL ON) +set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS OFF) # Component dependencies are NOT reflected in package relationships +set(CPACK_COMPONENTS_ALL runtime dev cllayerinfo) + +set(PACKAGE_NAME_PREFIX "khronos-opencl-loader") + +## Package runtime component +set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME "${PACKAGE_NAME_PREFIX}-libopencl1") + +# Package file name in deb format: +# _-_.deb +set(CPACK_DEBIAN_RUNTIME_FILE_NAME "${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME}_${PACKAGE_VERSION_REVISION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb") +set(CPACK_DEBIAN_RUNTIME_PACKAGE_SECTION "libs") +# Dependencies +set(CPACK_DEBIAN_RUNTIME_PACKAGE_DEPENDS "libc6") +set(CPACK_DEBIAN_RUNTIME_PACKAGE_SUGGESTS "opencl-icd") +set(CPACK_DEBIAN_RUNTIME_PACKAGE_CONFLICTS "amd-app, libopencl1, nvidia-libopencl1-dev") +set(CPACK_DEBIAN_RUNTIME_PACKAGE_REPLACES "amd-app, libopencl1, nvidia-libopencl1-dev") +set(CPACK_DEBIAN_RUNTIME_PACKAGE_PROVIDES "libopencl-1.1-1, libopencl-1.2-1, libopencl-2.0-1, libopencl-2.1-1, libopencl-2.2-1, libopencl-3.0-1, libopencl1") + +## Package dev component +set(CPACK_DEBIAN_DEV_PACKAGE_NAME "${PACKAGE_NAME_PREFIX}-opencl-dev") + +# Package file name in deb format: +# _-_.deb +set(CPACK_DEBIAN_DEV_FILE_NAME "${CPACK_DEBIAN_DEV_PACKAGE_NAME}_${PACKAGE_VERSION_REVISION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb") +set(CPACK_DEBIAN_DEV_PACKAGE_SECTION "libdevel") + +# Dependencies +set(CPACK_DEBIAN_DEV_PACKAGE_DEPENDS "opencl-c-headers (>= ${CPACK_DEBIAN_PACKAGE_VERSION}) | opencl-headers (>= ${CPACK_DEBIAN_PACKAGE_VERSION}), ${CPACK_DEBIAN_RUNTIME_PACKAGE_NAME} (>= ${CPACK_DEBIAN_PACKAGE_VERSION}) | libopencl1") +set(CPACK_DEBIAN_DEV_PACKAGE_RECOMMENDS "libgl1-mesa-dev | libgl-dev") +set(CPACK_DEBIAN_DEV_PACKAGE_CONFLICTS "opencl-dev") +set(CPACK_DEBIAN_DEV_PACKAGE_BREAKS "amd-libopencl1, nvidia-libopencl1") +set(CPACK_DEBIAN_DEV_PACKAGE_REPLACES "amd-libopencl1, nvidia-libopencl1, opencl-dev") +set(CPACK_DEBIAN_DEV_PACKAGE_PROVIDES "opencl-dev") + +## Package cllayerinfo component +set(CPACK_DEBIAN_CLLAYERINFO_PACKAGE_NAME "${PACKAGE_NAME_PREFIX}-cllayerinfo") +set(CPACK_DEBIAN_CLLAYERINFO_FILE_NAME "${CPACK_DEBIAN_CLLAYERINFO_PACKAGE_NAME}_${PACKAGE_VERSION_REVISION}_${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}.deb") +# Dependencies +set(CPACK_DEBIAN_CLLAYERINFO_PACKAGE_DEPENDS "libc6") +set(CPACK_DEBIAN_CLLAYERINFO_PACKAGE_SECTION "admin") diff --git a/deps/opencl-icd-loader/loader/cllayerinfo.c b/deps/opencl-icd-loader/loader/cllayerinfo.c new file mode 100644 index 000000000..5a85ba82d --- /dev/null +++ b/deps/opencl-icd-loader/loader/cllayerinfo.c @@ -0,0 +1,132 @@ +/* + * 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. + * + * OpenCL is a trademark of Apple Inc. used under license by Khronos. + */ + +#include "icd.h" +#include +#include +#include +#if defined(_WIN32) +#include +#include +#include +#else +#include +#endif +#include + +int stdout_bak, stderr_bak; + +// Temporarily deactivate stdout: +// https://stackoverflow.com/a/4832902 + +#if defined(_WIN32) +#define SECURE 1 +#define OPEN _open +#define OPEN_FLAGS _O_WRONLY +#define CLOSE _close +#define DUP _dup +#define DUP2 _dup2 +#define NULL_STREAM "nul" +#else +#define OPEN open +#define OPEN_FLAGS O_WRONLY +#define CLOSE close +#define DUP dup +#define DUP2 dup2 +#define NULL_STREAM "/dev/null" +#endif + +static inline int +silence_stream(FILE *file, int fd) +{ + int new_fd, fd_bak; + fflush(file); + fd_bak = DUP(fd); +#if defined(_WIN32) && SECURE + _sopen_s(&new_fd, NULL_STREAM, OPEN_FLAGS, _SH_DENYNO, _S_IWRITE); +#else + new_fd = OPEN(NULL_STREAM, OPEN_FLAGS); +#endif + DUP2(new_fd, fd); + CLOSE(new_fd); + return fd_bak; +} + +static void silence_layers(void) +{ + stdout_bak = silence_stream(stdout, 1); + stderr_bak = silence_stream(stderr, 2); +} + +static inline void +restore_stream(FILE *file, int fd, int fd_bak) +{ + fflush(file); + DUP2(fd_bak, fd); + CLOSE(fd_bak); +} + +static void restore_outputs(void) +{ + restore_stream(stdout, 1, stdout_bak); + restore_stream(stderr, 2, stderr_bak); +} + +void printLayerInfo(const struct KHRLayer *layer) +{ + cl_layer_api_version api_version = 0; + pfn_clGetLayerInfo p_clGetLayerInfo = (pfn_clGetLayerInfo)(size_t)layer->p_clGetLayerInfo; + cl_int result = CL_SUCCESS; + size_t sz; + + printf("%s:\n", layer->libraryName); + result = p_clGetLayerInfo(CL_LAYER_API_VERSION, sizeof(api_version), &api_version, NULL); + if (CL_SUCCESS == result) + printf("\tCL_LAYER_API_VERSION: %d\n", (int)api_version); + + result = p_clGetLayerInfo(CL_LAYER_NAME, 0, NULL, &sz); + if (CL_SUCCESS == result) + { + char *name = (char *)malloc(sz); + if (name) + { + result = p_clGetLayerInfo(CL_LAYER_NAME, sz, name, NULL); + if (CL_SUCCESS == result) + printf("\tCL_LAYER_NAME: %s\n", name); + free(name); + } + } +} + +int main (int argc, char *argv[]) +{ + (void)argc; + (void)argv; + silence_layers(); + atexit(restore_outputs); + khrIcdInitialize(); + restore_outputs(); + atexit(silence_layers); + const struct KHRLayer *layer = khrFirstLayer; + while (layer) + { + printLayerInfo(layer); + layer = layer->next; + } + return 0; +} diff --git a/deps/opencl-icd-loader/loader/icd.c b/deps/opencl-icd-loader/loader/icd.c index ea4c3f5d9..b92a9b4a8 100644 --- a/deps/opencl-icd-loader/loader/icd.c +++ b/deps/opencl-icd-loader/loader/icd.c @@ -48,7 +48,6 @@ void khrIcdInitializeTrace(void) // entrypoint to initialize the ICD and add all vendors void khrIcdInitialize(void) { - khrIcdInitializeTrace(); // enumerate vendors present on the system khrIcdOsVendorsEnumerateOnce(); } @@ -286,6 +285,20 @@ void khrIcdLayerAdd(const char *libraryName) KHR_ICD_TRACE("failed to allocate memory\n"); goto Done; } +#ifdef CL_LAYER_INFO + { + // Not using strdup as it is not standard c + size_t sz_name = strlen(libraryName) + 1; + layer->libraryName = malloc(sz_name); + if (!layer->libraryName) + { + KHR_ICD_TRACE("failed to allocate memory\n"); + goto Done; + } + memcpy(layer->libraryName, libraryName, sz_name); + layer->p_clGetLayerInfo = (void *)(size_t)p_clGetLayerInfo; + } +#endif if (khrFirstLayer) { targetDispatch = &(khrFirstLayer->dispatch); @@ -313,11 +326,11 @@ void khrIcdLayerAdd(const char *libraryName) for (cl_uint i = 0; i < limit; i++) { ((void **)&(layer->dispatch))[i] = - ((void **)layerDispatch)[i] ? - ((void **)layerDispatch)[i] : ((void **)targetDispatch)[i]; + ((void *const*)layerDispatch)[i] ? + ((void *const*)layerDispatch)[i] : ((void *const*)targetDispatch)[i]; } for (cl_uint i = limit; i < loaderDispatchNumEntries; i++) { - ((void **)&(layer->dispatch))[i] = ((void **)targetDispatch)[i]; + ((void **)&(layer->dispatch))[i] = ((void *const*)targetDispatch)[i]; } KHR_ICD_TRACE("successfully added layer %s\n", libraryName); diff --git a/deps/opencl-icd-loader/loader/icd.h b/deps/opencl-icd-loader/loader/icd.h index 13b64fd62..93723aafd 100644 --- a/deps/opencl-icd-loader/loader/icd.h +++ b/deps/opencl-icd-loader/loader/icd.h @@ -33,6 +33,18 @@ #define CL_USE_DEPRECATED_OPENCL_1_2_APIS #endif +#ifndef CL_USE_DEPRECATED_OPENCL_2_0_APIS +#define CL_USE_DEPRECATED_OPENCL_2_0_APIS +#endif + +#ifndef CL_USE_DEPRECATED_OPENCL_2_1_APIS +#define CL_USE_DEPRECATED_OPENCL_2_1_APIS +#endif + +#ifndef CL_USE_DEPRECATED_OPENCL_2_2_APIS +#define CL_USE_DEPRECATED_OPENCL_2_2_APIS +#endif + #include #include #include @@ -42,19 +54,19 @@ * type definitions */ -typedef CL_API_ENTRY cl_int (CL_API_CALL *pfn_clIcdGetPlatformIDs)( +typedef cl_int (CL_API_CALL *pfn_clIcdGetPlatformIDs)( cl_uint num_entries, cl_platform_id *platforms, cl_uint *num_platforms) CL_API_SUFFIX__VERSION_1_0; -typedef CL_API_ENTRY cl_int (CL_API_CALL *pfn_clGetPlatformInfo)( +typedef cl_int (CL_API_CALL *pfn_clGetPlatformInfo)( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0; -typedef CL_API_ENTRY void *(CL_API_CALL *pfn_clGetExtensionFunctionAddress)( +typedef void *(CL_API_CALL *pfn_clGetExtensionFunctionAddress)( const char *function_name) CL_API_SUFFIX__VERSION_1_0; typedef struct KHRicdVendorRec KHRicdVendor; @@ -85,13 +97,7 @@ struct KHRicdVendorRec // the global state extern KHRicdVendor * khrIcdVendors; -#ifdef __cplusplus -extern "C" { -#endif - extern int khrEnableTrace; -#ifdef __cplusplus -} -#endif +extern int khrEnableTrace; #if defined(CL_ENABLE_LAYERS) /* @@ -108,6 +114,12 @@ struct KHRLayer struct _cl_icd_dispatch dispatch; // The next layer in the chain struct KHRLayer *next; +#ifdef CL_LAYER_INFO + // The layer library name + char *libraryName; + // the pointer to the clGetLayerInfo funciton + void *p_clGetLayerInfo; +#endif }; // the global layer state @@ -126,6 +138,9 @@ extern struct _cl_icd_dispatch khrMasterDispatch; // API (e.g, getPlatformIDs, etc). void khrIcdInitialize(void); +// entrypoint to check and initialize trace. +void khrIcdInitializeTrace(void); + // go through the list of vendors (in /etc/OpenCL.conf or through // the registry) and call khrIcdVendorAdd for each vendor encountered // n.b, this call is OS-specific @@ -186,41 +201,46 @@ do \ #define KHR_ICD_WIDE_TRACE(...) #endif -#define KHR_ICD_ASSERT(x) \ -do \ -{ \ - if (khrEnableTrace) \ - { \ - if (!(x)) \ - { \ - fprintf(stderr, "KHR ICD assert at %s:%d: %s failed", __FILE__, __LINE__, #x); \ - } \ - } \ +// Check if the passed-in handle is NULL, and if it is, return the error. +#define KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(_handle, _error) \ +do { \ + if (!_handle) { \ + return _error; \ + } \ } while (0) -// if handle is NULL then return invalid_handle_error_code -#define KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(handle,invalid_handle_error_code) \ -do \ -{ \ - if (!handle) \ - { \ - return invalid_handle_error_code; \ - } \ +// Check if the passed-in handle is NULL, and if it is, first check and set +// errcode_ret to the error, then return NULL (NULL being an invalid handle). +#define KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(_handle, _error) \ +do { \ + if (!_handle) { \ + if (errcode_ret) { \ + *errcode_ret = _error; \ + } \ + return NULL; \ + } \ } while (0) -// if handle is NULL then set errcode_ret to invalid_handle_error and return NULL -// (NULL being an invalid handle) -#define KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(handle,invalid_handle_error) \ -do \ -{ \ - if (!handle) \ - { \ - if (errcode_ret) \ - { \ - *errcode_ret = invalid_handle_error; \ - } \ - return NULL; \ - } \ +// Check if the passed-in function pointer is NULL, and if it is, return +// CL_INVALID_OPERATION. +#define KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(_pointer) \ +do { \ + if (!_pointer) { \ + return CL_INVALID_OPERATION; \ + } \ +} while (0) + +// Check if the passed-in function pointer is NULL, and if it is, first +// check and set errcode_ret to CL_INVALID_OPERATION, then return NULL +// (NULL being an invalid handle). +#define KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(_pointer) \ +do { \ + if (!_pointer) { \ + if (errcode_ret) { \ + *errcode_ret = CL_INVALID_OPERATION; \ + } \ + return NULL; \ + } \ } while (0) #endif diff --git a/deps/opencl-icd-loader/loader/icd_dispatch.c b/deps/opencl-icd-loader/loader/icd_dispatch.c index 2e837eede..51ec52d60 100644 --- a/deps/opencl-icd-loader/loader/icd_dispatch.c +++ b/deps/opencl-icd-loader/loader/icd_dispatch.c @@ -16,11 +16,55 @@ * OpenCL is a trademark of Apple Inc. used under license by Khronos. */ -#include "icd_dispatch.h" #include "icd.h" +#include "icd_dispatch.h" +#include "icd_version.h" + #include #include +static clGetICDLoaderInfoOCLICD_t clGetICDLoaderInfoOCLICD; +cl_int CL_API_CALL +clGetICDLoaderInfoOCLICD( + cl_icdl_info param_name, + size_t param_value_size, + void * param_value, + size_t * param_value_size_ret) +{ + static const char cl_icdl_OCL_VERSION[] = OPENCL_ICD_LOADER_OCL_VERSION_STRING; + static const char cl_icdl_VERSION[] = OPENCL_ICD_LOADER_VERSION_STRING; + static const char cl_icdl_NAME[] = OPENCL_ICD_LOADER_NAME_STRING; + static const char cl_icdl_VENDOR[] = OPENCL_ICD_LOADER_VENDOR_STRING; + size_t pvs; + const void * pv = NULL; + +#define KHR_ICD_CASE_STRING_PARAM_NAME(name) \ + case CL_ICDL_ ## name: \ + pvs = strlen(cl_icdl_ ## name) + 1; \ + pv = (const void *)cl_icdl_ ## name; \ + break + + switch (param_name) { + KHR_ICD_CASE_STRING_PARAM_NAME(OCL_VERSION); + KHR_ICD_CASE_STRING_PARAM_NAME(VERSION); + KHR_ICD_CASE_STRING_PARAM_NAME(NAME); + KHR_ICD_CASE_STRING_PARAM_NAME(VENDOR); + default: + return CL_INVALID_VALUE; + } + +#undef KHR_ICD_CASE_PARAM_NAME + + if (param_value) { + if (param_value_size < pvs) + return CL_INVALID_VALUE; + memcpy(param_value, pv, pvs); + } + if (param_value_size_ret != NULL) + *param_value_size_ret = pvs; + return CL_SUCCESS; +} + static void* khrIcdGetExtensionFunctionAddress(const char* function_name) { // Most extensions, including multi-vendor KHR and EXT extensions, @@ -92,6 +136,9 @@ static void* khrIcdGetExtensionFunctionAddress(const char* function_name) // cl_khr_sub_groups KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetKernelSubGroupInfoKHR); + // cl_icdl + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetICDLoaderInfoOCLICD); + #undef KHR_ICD_CHECK_EXTENSION_FUNCTION return NULL; @@ -147,7 +194,7 @@ static inline cl_int clGetPlatformIDs_body( return CL_SUCCESS; } -CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_disp( +cl_int CL_API_CALL clGetPlatformIDs_disp( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms) @@ -215,7 +262,7 @@ static inline void* clGetExtensionFunctionAddress_body( return NULL; } -CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_disp( +void* CL_API_CALL clGetExtensionFunctionAddress_disp( const char* function_name) { return clGetExtensionFunctionAddress_body( @@ -261,7 +308,7 @@ static inline void* clGetExtensionFunctionAddressForPlatform_body( function_name); } -CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( +void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( cl_platform_id platform, const char* function_name) { diff --git a/deps/opencl-icd-loader/loader/icd_dispatch_generated.c b/deps/opencl-icd-loader/loader/icd_dispatch_generated.c index 2cd984c71..3aa788ac0 100644 --- a/deps/opencl-icd-loader/loader/icd_dispatch_generated.c +++ b/deps/opencl-icd-loader/loader/icd_dispatch_generated.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2020 The Khronos Group Inc. + * Copyright (c) 2012-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. @@ -16,8 +16,8 @@ * OpenCL is a trademark of Apple Inc. used under license by Khronos. */ -#include "icd_dispatch.h" #include "icd.h" +#include "icd_dispatch.h" #ifdef __cplusplus extern "C" { @@ -26,13 +26,12 @@ extern "C" { /////////////////////////////////////////////////////////////////////////////// // Core APIs: #if defined(CL_ENABLE_LAYERS) -extern CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_disp( +extern cl_int CL_API_CALL clGetPlatformIDs_disp( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0; #endif // defined(CL_ENABLE_LAYERS) - CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo( cl_platform_id platform, cl_platform_info param_name, @@ -60,7 +59,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo_disp( +static cl_int CL_API_CALL clGetPlatformInfo_disp( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, @@ -106,7 +105,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs_disp( +static cl_int CL_API_CALL clGetDeviceIDs_disp( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, @@ -152,7 +151,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo_disp( +static cl_int CL_API_CALL clGetDeviceInfo_disp( cl_device_id device, cl_device_info param_name, size_t param_value_size, @@ -204,7 +203,7 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContext( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_context CL_API_CALL clCreateContext_disp( +static cl_context CL_API_CALL clCreateContext_disp( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, @@ -258,7 +257,7 @@ CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType_disp( +static cl_context CL_API_CALL clCreateContextFromType_disp( const cl_context_properties* properties, cl_device_type device_type, void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), @@ -295,7 +294,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainContext( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainContext_disp( +static cl_int CL_API_CALL clRetainContext_disp( cl_context context) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); @@ -321,7 +320,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseContext( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseContext_disp( +static cl_int CL_API_CALL clReleaseContext_disp( cl_context context) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); @@ -359,7 +358,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo_disp( +static cl_int CL_API_CALL clGetContextInfo_disp( cl_context context, cl_context_info param_name, size_t param_value_size, @@ -393,7 +392,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue_disp( +static cl_int CL_API_CALL clRetainCommandQueue_disp( cl_command_queue command_queue) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); @@ -419,7 +418,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue_disp( +static cl_int CL_API_CALL clReleaseCommandQueue_disp( cl_command_queue command_queue) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); @@ -457,7 +456,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo_disp( +static cl_int CL_API_CALL clGetCommandQueueInfo_disp( cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size, @@ -503,7 +502,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer_disp( +static cl_mem CL_API_CALL clCreateBuffer_disp( cl_context context, cl_mem_flags flags, size_t size, @@ -537,7 +536,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject_disp( +static cl_int CL_API_CALL clRetainMemObject_disp( cl_mem memobj) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); @@ -563,7 +562,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject_disp( +static cl_int CL_API_CALL clReleaseMemObject_disp( cl_mem memobj) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); @@ -604,7 +603,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats_disp( +static cl_int CL_API_CALL clGetSupportedImageFormats_disp( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -652,7 +651,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo_disp( +static cl_int CL_API_CALL clGetMemObjectInfo_disp( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, @@ -698,7 +697,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo_disp( +static cl_int CL_API_CALL clGetImageInfo_disp( cl_mem image, cl_image_info param_name, size_t param_value_size, @@ -732,7 +731,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainSampler( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainSampler_disp( +static cl_int CL_API_CALL clRetainSampler_disp( cl_sampler sampler) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); @@ -758,7 +757,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler_disp( +static cl_int CL_API_CALL clReleaseSampler_disp( cl_sampler sampler) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); @@ -796,7 +795,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo_disp( +static cl_int CL_API_CALL clGetSamplerInfo_disp( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, @@ -842,7 +841,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource_disp( +static cl_program CL_API_CALL clCreateProgramWithSource_disp( cl_context context, cl_uint count, const char** strings, @@ -894,7 +893,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary_disp( +static cl_program CL_API_CALL clCreateProgramWithBinary_disp( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -932,7 +931,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainProgram_disp( +static cl_int CL_API_CALL clRetainProgram_disp( cl_program program) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); @@ -958,7 +957,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram_disp( +static cl_int CL_API_CALL clReleaseProgram_disp( cl_program program) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); @@ -999,7 +998,7 @@ CL_API_ENTRY cl_int CL_API_CALL clBuildProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clBuildProgram_disp( +static cl_int CL_API_CALL clBuildProgram_disp( cl_program program, cl_uint num_devices, const cl_device_id* device_list, @@ -1047,7 +1046,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo_disp( +static cl_int CL_API_CALL clGetProgramInfo_disp( cl_program program, cl_program_info param_name, size_t param_value_size, @@ -1096,7 +1095,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo_disp( +static cl_int CL_API_CALL clGetProgramBuildInfo_disp( cl_program program, cl_device_id device, cl_program_build_info param_name, @@ -1138,7 +1137,7 @@ CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel_disp( +static cl_kernel CL_API_CALL clCreateKernel_disp( cl_program program, const char* kernel_name, cl_int* errcode_ret) @@ -1177,7 +1176,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram_disp( +static cl_int CL_API_CALL clCreateKernelsInProgram_disp( cl_program program, cl_uint num_kernels, cl_kernel* kernels, @@ -1209,7 +1208,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainKernel_disp( +static cl_int CL_API_CALL clRetainKernel_disp( cl_kernel kernel) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); @@ -1235,7 +1234,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel_disp( +static cl_int CL_API_CALL clReleaseKernel_disp( cl_kernel kernel) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); @@ -1270,7 +1269,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg_disp( +static cl_int CL_API_CALL clSetKernelArg_disp( cl_kernel kernel, cl_uint arg_index, size_t arg_size, @@ -1314,7 +1313,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo_disp( +static cl_int CL_API_CALL clGetKernelInfo_disp( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, @@ -1363,7 +1362,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo_disp( +static cl_int CL_API_CALL clGetKernelWorkGroupInfo_disp( cl_kernel kernel, cl_device_id device, cl_kernel_work_group_info param_name, @@ -1405,7 +1404,7 @@ CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents_disp( +static cl_int CL_API_CALL clWaitForEvents_disp( cl_uint num_events, const cl_event* event_list) { @@ -1448,7 +1447,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo_disp( +static cl_int CL_API_CALL clGetEventInfo_disp( cl_event event, cl_event_info param_name, size_t param_value_size, @@ -1482,7 +1481,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainEvent( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainEvent_disp( +static cl_int CL_API_CALL clRetainEvent_disp( cl_event event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); @@ -1508,7 +1507,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent_disp( +static cl_int CL_API_CALL clReleaseEvent_disp( cl_event event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); @@ -1546,7 +1545,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo_disp( +static cl_int CL_API_CALL clGetEventProfilingInfo_disp( cl_event event, cl_profiling_info param_name, size_t param_value_size, @@ -1580,7 +1579,7 @@ CL_API_ENTRY cl_int CL_API_CALL clFlush( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clFlush_disp( +static cl_int CL_API_CALL clFlush_disp( cl_command_queue command_queue) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); @@ -1606,7 +1605,7 @@ CL_API_ENTRY cl_int CL_API_CALL clFinish( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clFinish_disp( +static cl_int CL_API_CALL clFinish_disp( cl_command_queue command_queue) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); @@ -1656,7 +1655,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer_disp( +static cl_int CL_API_CALL clEnqueueReadBuffer_disp( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, @@ -1722,7 +1721,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer_disp( +static cl_int CL_API_CALL clEnqueueWriteBuffer_disp( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, @@ -1788,7 +1787,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer_disp( +static cl_int CL_API_CALL clEnqueueCopyBuffer_disp( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, @@ -1860,7 +1859,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage_disp( +static cl_int CL_API_CALL clEnqueueReadImage_disp( cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, @@ -1936,7 +1935,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage_disp( +static cl_int CL_API_CALL clEnqueueWriteImage_disp( cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, @@ -2006,7 +2005,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage_disp( +static cl_int CL_API_CALL clEnqueueCopyImage_disp( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, @@ -2072,7 +2071,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer_disp( +static cl_int CL_API_CALL clEnqueueCopyImageToBuffer_disp( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, @@ -2138,7 +2137,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage_disp( +static cl_int CL_API_CALL clEnqueueCopyBufferToImage_disp( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, @@ -2207,7 +2206,7 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer_disp( +static void* CL_API_CALL clEnqueueMapBuffer_disp( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, @@ -2284,7 +2283,7 @@ CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage_disp( +static void* CL_API_CALL clEnqueueMapImage_disp( cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, @@ -2347,7 +2346,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject_disp( +static cl_int CL_API_CALL clEnqueueUnmapMemObject_disp( cl_command_queue command_queue, cl_mem memobj, void* mapped_ptr, @@ -2407,7 +2406,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel_disp( +static cl_int CL_API_CALL clEnqueueNDRangeKernel_disp( cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, @@ -2476,7 +2475,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel_disp( +static cl_int CL_API_CALL clEnqueueNativeKernel_disp( cl_command_queue command_queue, void (CL_CALLBACK* user_func)(void*), void* args, @@ -2529,7 +2528,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty_disp( +static cl_int CL_API_CALL clSetCommandQueueProperty_disp( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, @@ -2582,7 +2581,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D_disp( +static cl_mem CL_API_CALL clCreateImage2D_disp( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -2649,7 +2648,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D_disp( +static cl_mem CL_API_CALL clCreateImage3D_disp( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -2696,7 +2695,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker_disp( +static cl_int CL_API_CALL clEnqueueMarker_disp( cl_command_queue command_queue, cl_event* event) { @@ -2730,7 +2729,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents_disp( +static cl_int CL_API_CALL clEnqueueWaitForEvents_disp( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list) @@ -2760,7 +2759,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier_disp( +static cl_int CL_API_CALL clEnqueueBarrier_disp( cl_command_queue command_queue) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); @@ -2785,7 +2784,7 @@ CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_disp( +static cl_int CL_API_CALL clUnloadCompiler_disp( void ) { // Nothing! @@ -2795,11 +2794,10 @@ static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_disp( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_disp( +extern void* CL_API_CALL clGetExtensionFunctionAddress_disp( const char* func_name) CL_API_SUFFIX__VERSION_1_1_DEPRECATED; #endif // defined(CL_ENABLE_LAYERS) - CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue( cl_context context, cl_device_id device, @@ -2824,7 +2822,7 @@ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue_disp( +static cl_command_queue CL_API_CALL clCreateCommandQueue_disp( cl_context context, cl_device_id device, cl_command_queue_properties properties, @@ -2868,7 +2866,7 @@ CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler_disp( +static cl_sampler CL_API_CALL clCreateSampler_disp( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, @@ -2914,7 +2912,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask_disp( +static cl_int CL_API_CALL clEnqueueTask_disp( cl_command_queue command_queue, cl_kernel kernel, cl_uint num_events_in_wait_list, @@ -2960,7 +2958,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer_disp( +static cl_mem CL_API_CALL clCreateSubBuffer_disp( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, @@ -3000,7 +2998,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback_disp( +static cl_int CL_API_CALL clSetMemObjectDestructorCallback_disp( cl_mem memobj, void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), void* user_data) @@ -3033,7 +3031,7 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent_disp( +static cl_event CL_API_CALL clCreateUserEvent_disp( cl_context context, cl_int* errcode_ret) { @@ -3064,7 +3062,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus_disp( +static cl_int CL_API_CALL clSetUserEventStatus_disp( cl_event event, cl_int execution_status) { @@ -3101,7 +3099,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback_disp( +static cl_int CL_API_CALL clSetEventCallback_disp( cl_event event, cl_int command_exec_callback_type, void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), @@ -3172,7 +3170,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect_disp( +static cl_int CL_API_CALL clEnqueueReadBufferRect_disp( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, @@ -3263,7 +3261,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect_disp( +static cl_int CL_API_CALL clEnqueueWriteBufferRect_disp( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, @@ -3351,7 +3349,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect_disp( +static cl_int CL_API_CALL clEnqueueCopyBufferRect_disp( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, @@ -3413,7 +3411,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices_disp( +static cl_int CL_API_CALL clCreateSubDevices_disp( cl_device_id in_device, const cl_device_partition_property* properties, cl_uint num_devices, @@ -3447,7 +3445,7 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainDevice( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainDevice_disp( +static cl_int CL_API_CALL clRetainDevice_disp( cl_device_id device) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); @@ -3473,7 +3471,7 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice_disp( +static cl_int CL_API_CALL clReleaseDevice_disp( cl_device_id device) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); @@ -3514,7 +3512,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage_disp( +static cl_mem CL_API_CALL clCreateImage_disp( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -3562,7 +3560,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_disp( +static cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_disp( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -3620,7 +3618,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCompileProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clCompileProgram_disp( +static cl_int CL_API_CALL clCompileProgram_disp( cl_program program, cl_uint num_devices, const cl_device_id* device_list, @@ -3686,7 +3684,7 @@ CL_API_ENTRY cl_program CL_API_CALL clLinkProgram( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_program CL_API_CALL clLinkProgram_disp( +static cl_program CL_API_CALL clLinkProgram_disp( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -3728,7 +3726,7 @@ CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler_disp( +static cl_int CL_API_CALL clUnloadPlatformCompiler_disp( cl_platform_id platform) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); @@ -3769,7 +3767,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo_disp( +static cl_int CL_API_CALL clGetKernelArgInfo_disp( cl_kernel kernel, cl_uint arg_index, cl_kernel_arg_info param_name, @@ -3829,7 +3827,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer_disp( +static cl_int CL_API_CALL clEnqueueFillBuffer_disp( cl_command_queue command_queue, cl_mem buffer, const void* pattern, @@ -3892,7 +3890,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage_disp( +static cl_int CL_API_CALL clEnqueueFillImage_disp( cl_command_queue command_queue, cl_mem image, const void* fill_color, @@ -3950,7 +3948,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects_disp( +static cl_int CL_API_CALL clEnqueueMigrateMemObjects_disp( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, @@ -3997,7 +3995,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList_disp( +static cl_int CL_API_CALL clEnqueueMarkerWithWaitList_disp( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, @@ -4038,7 +4036,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_disp( +static cl_int CL_API_CALL clEnqueueBarrierWithWaitList_disp( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, @@ -4055,12 +4053,11 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_disp( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -extern CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( +extern void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( cl_platform_id platform, const char* func_name) CL_API_SUFFIX__VERSION_1_2; #endif // defined(CL_ENABLE_LAYERS) - CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties( cl_context context, cl_device_id device, @@ -4085,7 +4082,7 @@ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_disp( +static cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_disp( cl_context context, cl_device_id device, const cl_queue_properties* properties, @@ -4132,7 +4129,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe_disp( +static cl_mem CL_API_CALL clCreatePipe_disp( cl_context context, cl_mem_flags flags, cl_uint pipe_packet_size, @@ -4180,7 +4177,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo_disp( +static cl_int CL_API_CALL clGetPipeInfo_disp( cl_mem pipe, cl_pipe_info param_name, size_t param_value_size, @@ -4223,7 +4220,7 @@ CL_API_ENTRY void* CL_API_CALL clSVMAlloc( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY void* CL_API_CALL clSVMAlloc_disp( +static void* CL_API_CALL clSVMAlloc_disp( cl_context context, cl_svm_mem_flags flags, size_t size, @@ -4261,7 +4258,7 @@ CL_API_ENTRY void CL_API_CALL clSVMFree( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY void CL_API_CALL clSVMFree_disp( +static void CL_API_CALL clSVMFree_disp( cl_context context, void* svm_pointer) { @@ -4295,7 +4292,7 @@ CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties_disp( +static cl_sampler CL_API_CALL clCreateSamplerWithProperties_disp( cl_context context, const cl_sampler_properties* sampler_properties, cl_int* errcode_ret) @@ -4331,7 +4328,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer_disp( +static cl_int CL_API_CALL clSetKernelArgSVMPointer_disp( cl_kernel kernel, cl_uint arg_index, const void* arg_value) @@ -4370,7 +4367,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo_disp( +static cl_int CL_API_CALL clSetKernelExecInfo_disp( cl_kernel kernel, cl_kernel_exec_info param_name, size_t param_value_size, @@ -4423,7 +4420,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree_disp( +static cl_int CL_API_CALL clEnqueueSVMFree_disp( cl_command_queue command_queue, cl_uint num_svm_pointers, void* svm_pointers[], @@ -4484,7 +4481,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy_disp( +static cl_int CL_API_CALL clEnqueueSVMMemcpy_disp( cl_command_queue command_queue, cl_bool blocking_copy, void* dst_ptr, @@ -4545,7 +4542,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill_disp( +static cl_int CL_API_CALL clEnqueueSVMMemFill_disp( cl_command_queue command_queue, void* svm_ptr, const void* pattern, @@ -4606,7 +4603,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap_disp( +static cl_int CL_API_CALL clEnqueueSVMMap_disp( cl_command_queue command_queue, cl_bool blocking_map, cl_map_flags flags, @@ -4658,7 +4655,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap_disp( +static cl_int CL_API_CALL clEnqueueSVMUnmap_disp( cl_command_queue command_queue, void* svm_ptr, cl_uint num_events_in_wait_list, @@ -4698,7 +4695,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_disp( +static cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_disp( cl_context context, cl_device_id device, cl_command_queue command_queue) @@ -4734,7 +4731,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer_disp( +static cl_int CL_API_CALL clGetDeviceAndHostTimer_disp( cl_device_id device, cl_ulong* device_timestamp, cl_ulong* host_timestamp) @@ -4767,7 +4764,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer_disp( +static cl_int CL_API_CALL clGetHostTimer_disp( cl_device_id device, cl_ulong* host_timestamp) { @@ -4804,7 +4801,7 @@ CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL_disp( +static cl_program CL_API_CALL clCreateProgramWithIL_disp( cl_context context, const void* il, size_t length, @@ -4839,7 +4836,7 @@ CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel_disp( +static cl_kernel CL_API_CALL clCloneKernel_disp( cl_kernel source_kernel, cl_int* errcode_ret) { @@ -4888,7 +4885,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo_disp( +static cl_int CL_API_CALL clGetKernelSubGroupInfo_disp( cl_kernel kernel, cl_device_id device, cl_kernel_sub_group_info param_name, @@ -4949,7 +4946,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem_disp( +static cl_int CL_API_CALL clEnqueueSVMMigrateMem_disp( cl_command_queue command_queue, cl_uint num_svm_pointers, const void** svm_pointers, @@ -4998,7 +4995,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant_disp( +static cl_int CL_API_CALL clSetProgramSpecializationConstant_disp( cl_program program, cl_uint spec_id, size_t spec_size, @@ -5036,7 +5033,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback_disp( +static cl_int CL_API_CALL clSetProgramReleaseCallback_disp( cl_program program, void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), void* user_data) @@ -5072,7 +5069,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback_disp( +static cl_int CL_API_CALL clSetContextDestructorCallback_disp( cl_context context, void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), void* user_data) @@ -5117,7 +5114,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties_disp( +static cl_mem CL_API_CALL clCreateBufferWithProperties_disp( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, @@ -5171,7 +5168,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties( /////////////////////////////////////////////////////////////////////////////// #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties_disp( +static cl_mem CL_API_CALL clCreateImageWithProperties_disp( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, @@ -5205,14 +5202,16 @@ CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT( device); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(device->dispatch->clReleaseDeviceEXT); return device->dispatch->clReleaseDeviceEXT( device); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT_disp( +static cl_int CL_API_CALL clReleaseDeviceEXT_disp( cl_device_id device) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(device->dispatch->clReleaseDeviceEXT); return device->dispatch->clReleaseDeviceEXT( device); } @@ -5227,14 +5226,16 @@ CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT( device); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(device->dispatch->clRetainDeviceEXT); return device->dispatch->clRetainDeviceEXT( device); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT_disp( +static cl_int CL_API_CALL clRetainDeviceEXT_disp( cl_device_id device) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(device->dispatch->clRetainDeviceEXT); return device->dispatch->clRetainDeviceEXT( device); } @@ -5257,6 +5258,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT( num_devices); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(in_device->dispatch->clCreateSubDevicesEXT); return in_device->dispatch->clCreateSubDevicesEXT( in_device, properties, @@ -5265,7 +5267,7 @@ CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT( num_devices); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_disp( +static cl_int CL_API_CALL clCreateSubDevicesEXT_disp( cl_device_id in_device, const cl_device_partition_property_ext* properties, cl_uint num_entries, @@ -5273,6 +5275,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_disp( cl_uint* num_devices) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(in_device->dispatch->clCreateSubDevicesEXT); return in_device->dispatch->clCreateSubDevicesEXT( in_device, properties, @@ -5309,6 +5312,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR( num_devices); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromD3D10KHR); return platform->dispatch->clGetDeviceIDsFromD3D10KHR( platform, d3d_device_source, @@ -5319,7 +5323,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR( num_devices); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp( +static cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void* d3d_object, @@ -5329,6 +5333,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp( cl_uint* num_devices) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromD3D10KHR); return platform->dispatch->clGetDeviceIDsFromD3D10KHR( platform, d3d_device_source, @@ -5355,6 +5360,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10BufferKHR); return context->dispatch->clCreateFromD3D10BufferKHR( context, flags, @@ -5362,13 +5368,14 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_disp( cl_context context, cl_mem_flags flags, ID3D10Buffer* resource, cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10BufferKHR); return context->dispatch->clCreateFromD3D10BufferKHR( context, flags, @@ -5394,6 +5401,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10Texture2DKHR); return context->dispatch->clCreateFromD3D10Texture2DKHR( context, flags, @@ -5402,7 +5410,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp( cl_context context, cl_mem_flags flags, ID3D10Texture2D* resource, @@ -5410,6 +5418,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10Texture2DKHR); return context->dispatch->clCreateFromD3D10Texture2DKHR( context, flags, @@ -5436,6 +5445,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10Texture3DKHR); return context->dispatch->clCreateFromD3D10Texture3DKHR( context, flags, @@ -5444,7 +5454,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp( cl_context context, cl_mem_flags flags, ID3D10Texture3D* resource, @@ -5452,6 +5462,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D10Texture3DKHR); return context->dispatch->clCreateFromD3D10Texture3DKHR( context, flags, @@ -5480,6 +5491,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR); return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR( command_queue, num_objects, @@ -5489,7 +5501,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -5498,6 +5510,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR); return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR( command_queue, num_objects, @@ -5527,6 +5540,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR); return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR( command_queue, num_objects, @@ -5536,7 +5550,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -5545,6 +5559,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR); return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR( command_queue, num_objects, @@ -5584,6 +5599,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR( num_devices); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromD3D11KHR); return platform->dispatch->clGetDeviceIDsFromD3D11KHR( platform, d3d_device_source, @@ -5594,7 +5610,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR( num_devices); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp( +static cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void* d3d_object, @@ -5604,6 +5620,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp( cl_uint* num_devices) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromD3D11KHR); return platform->dispatch->clGetDeviceIDsFromD3D11KHR( platform, d3d_device_source, @@ -5630,6 +5647,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11BufferKHR); return context->dispatch->clCreateFromD3D11BufferKHR( context, flags, @@ -5637,13 +5655,14 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_disp( cl_context context, cl_mem_flags flags, ID3D11Buffer* resource, cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11BufferKHR); return context->dispatch->clCreateFromD3D11BufferKHR( context, flags, @@ -5669,6 +5688,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11Texture2DKHR); return context->dispatch->clCreateFromD3D11Texture2DKHR( context, flags, @@ -5677,7 +5697,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp( cl_context context, cl_mem_flags flags, ID3D11Texture2D* resource, @@ -5685,6 +5705,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11Texture2DKHR); return context->dispatch->clCreateFromD3D11Texture2DKHR( context, flags, @@ -5711,6 +5732,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11Texture3DKHR); return context->dispatch->clCreateFromD3D11Texture3DKHR( context, flags, @@ -5719,7 +5741,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp( +static cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp( cl_context context, cl_mem_flags flags, ID3D11Texture3D* resource, @@ -5727,6 +5749,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromD3D11Texture3DKHR); return context->dispatch->clCreateFromD3D11Texture3DKHR( context, flags, @@ -5755,6 +5778,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR); return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR( command_queue, num_objects, @@ -5764,7 +5788,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -5773,6 +5797,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR); return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR( command_queue, num_objects, @@ -5802,6 +5827,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR); return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR( command_queue, num_objects, @@ -5811,7 +5837,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -5820,6 +5846,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR); return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR( command_queue, num_objects, @@ -5861,6 +5888,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR( num_devices); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR); return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( platform, num_media_adapters, @@ -5872,7 +5900,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR( num_devices); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_disp( +static cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_disp( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr* media_adapter_type, @@ -5883,6 +5911,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_disp cl_uint* num_devices) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR); return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( platform, num_media_adapters, @@ -5914,6 +5943,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromDX9MediaSurfaceKHR); return context->dispatch->clCreateFromDX9MediaSurfaceKHR( context, flags, @@ -5923,7 +5953,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp( +static cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, @@ -5932,6 +5962,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromDX9MediaSurfaceKHR); return context->dispatch->clCreateFromDX9MediaSurfaceKHR( context, flags, @@ -5961,6 +5992,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR); return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR( command_queue, num_objects, @@ -5970,7 +6002,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp( +static cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -5979,6 +6011,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR); return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR( command_queue, num_objects, @@ -6008,6 +6041,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR); return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR( command_queue, num_objects, @@ -6017,7 +6051,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp( +static cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -6026,6 +6060,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR); return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR( command_queue, num_objects, @@ -6057,6 +6092,7 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateEventFromEGLSyncKHR); return context->dispatch->clCreateEventFromEGLSyncKHR( context, sync, @@ -6064,13 +6100,14 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_disp( +static cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_disp( cl_context context, CLeglSyncKHR sync, CLeglDisplayKHR display, cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateEventFromEGLSyncKHR); return context->dispatch->clCreateEventFromEGLSyncKHR( context, sync, @@ -6102,6 +6139,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromEGLImageKHR); return context->dispatch->clCreateFromEGLImageKHR( context, egldisplay, @@ -6111,7 +6149,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp( +static cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp( cl_context context, CLeglDisplayKHR egldisplay, CLeglImageKHR eglimage, @@ -6120,6 +6158,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromEGLImageKHR); return context->dispatch->clCreateFromEGLImageKHR( context, egldisplay, @@ -6149,6 +6188,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR); return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR( command_queue, num_objects, @@ -6158,7 +6198,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -6167,6 +6207,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR); return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR( command_queue, num_objects, @@ -6196,6 +6237,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR); return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR( command_queue, num_objects, @@ -6205,7 +6247,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp( +static cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -6214,6 +6256,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR); return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR( command_queue, num_objects, @@ -6241,18 +6284,20 @@ CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateEventFromGLsyncKHR); return context->dispatch->clCreateEventFromGLsyncKHR( context, sync, errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR_disp( +static cl_event CL_API_CALL clCreateEventFromGLsyncKHR_disp( cl_context context, cl_GLsync sync, cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateEventFromGLsyncKHR); return context->dispatch->clCreateEventFromGLsyncKHR( context, sync, @@ -6283,6 +6328,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR( cl_platform_id platform = NULL; khrIcdContextPropertiesGetPlatform(properties, &platform); KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetGLContextInfoKHR); return platform->dispatch->clGetGLContextInfoKHR( properties, param_name, @@ -6291,7 +6337,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR( param_value_size_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_disp( +static cl_int CL_API_CALL clGetGLContextInfoKHR_disp( const cl_context_properties* properties, cl_gl_context_info param_name, size_t param_value_size, @@ -6301,6 +6347,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_disp( cl_platform_id platform = NULL; khrIcdContextPropertiesGetPlatform(properties, &platform); KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->clGetGLContextInfoKHR); return platform->dispatch->clGetGLContextInfoKHR( properties, param_name, @@ -6314,7 +6361,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( cl_context context, cl_mem_flags flags, cl_GLuint bufobj, - int* errcode_ret) + cl_int* errcode_ret) { #if defined(CL_ENABLE_LAYERS) if (khrFirstLayer) @@ -6325,6 +6372,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLBuffer); return context->dispatch->clCreateFromGLBuffer( context, flags, @@ -6332,13 +6380,14 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer_disp( +static cl_mem CL_API_CALL clCreateFromGLBuffer_disp( cl_context context, cl_mem_flags flags, cl_GLuint bufobj, - int* errcode_ret) + cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLBuffer); return context->dispatch->clCreateFromGLBuffer( context, flags, @@ -6366,6 +6415,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture); return context->dispatch->clCreateFromGLTexture( context, flags, @@ -6375,7 +6425,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_disp( +static cl_mem CL_API_CALL clCreateFromGLTexture_disp( cl_context context, cl_mem_flags flags, cl_GLenum target, @@ -6384,6 +6434,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture); return context->dispatch->clCreateFromGLTexture( context, flags, @@ -6409,6 +6460,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLRenderbuffer); return context->dispatch->clCreateFromGLRenderbuffer( context, flags, @@ -6416,13 +6468,14 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer_disp( +static cl_mem CL_API_CALL clCreateFromGLRenderbuffer_disp( cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer, cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLRenderbuffer); return context->dispatch->clCreateFromGLRenderbuffer( context, flags, @@ -6444,18 +6497,20 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo( gl_object_name); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(memobj->dispatch->clGetGLObjectInfo); return memobj->dispatch->clGetGLObjectInfo( memobj, gl_object_type, gl_object_name); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo_disp( +static cl_int CL_API_CALL clGetGLObjectInfo_disp( cl_mem memobj, cl_gl_object_type* gl_object_type, cl_GLuint* gl_object_name) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(memobj->dispatch->clGetGLObjectInfo); return memobj->dispatch->clGetGLObjectInfo( memobj, gl_object_type, @@ -6480,6 +6535,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo( param_value_size_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(memobj->dispatch->clGetGLTextureInfo); return memobj->dispatch->clGetGLTextureInfo( memobj, param_name, @@ -6488,7 +6544,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo( param_value_size_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_disp( +static cl_int CL_API_CALL clGetGLTextureInfo_disp( cl_mem memobj, cl_gl_texture_info param_name, size_t param_value_size, @@ -6496,6 +6552,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_disp( size_t* param_value_size_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(memobj->dispatch->clGetGLTextureInfo); return memobj->dispatch->clGetGLTextureInfo( memobj, param_name, @@ -6524,6 +6581,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireGLObjects); return command_queue->dispatch->clEnqueueAcquireGLObjects( command_queue, num_objects, @@ -6533,7 +6591,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp( +static cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -6542,6 +6600,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueAcquireGLObjects); return command_queue->dispatch->clEnqueueAcquireGLObjects( command_queue, num_objects, @@ -6571,6 +6630,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects( event); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseGLObjects); return command_queue->dispatch->clEnqueueReleaseGLObjects( command_queue, num_objects, @@ -6580,7 +6640,7 @@ CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects( event); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp( +static cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -6589,6 +6649,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp( cl_event* event) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(command_queue->dispatch->clEnqueueReleaseGLObjects); return command_queue->dispatch->clEnqueueReleaseGLObjects( command_queue, num_objects, @@ -6618,6 +6679,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture2D); return context->dispatch->clCreateFromGLTexture2D( context, flags, @@ -6627,7 +6689,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_disp( +static cl_mem CL_API_CALL clCreateFromGLTexture2D_disp( cl_context context, cl_mem_flags flags, cl_GLenum target, @@ -6636,6 +6698,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture2D); return context->dispatch->clCreateFromGLTexture2D( context, flags, @@ -6665,6 +6728,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D( errcode_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture3D); return context->dispatch->clCreateFromGLTexture3D( context, flags, @@ -6674,7 +6738,7 @@ CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D( errcode_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_disp( +static cl_mem CL_API_CALL clCreateFromGLTexture3D_disp( cl_context context, cl_mem_flags flags, cl_GLenum target, @@ -6683,6 +6747,7 @@ static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_disp( cl_int* errcode_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(context->dispatch->clCreateFromGLTexture3D); return context->dispatch->clCreateFromGLTexture3D( context, flags, @@ -6720,6 +6785,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR( param_value_size_ret); #endif // defined(CL_ENABLE_LAYERS) KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(in_kernel->dispatch->clGetKernelSubGroupInfoKHR); return in_kernel->dispatch->clGetKernelSubGroupInfoKHR( in_kernel, in_device, @@ -6731,7 +6797,7 @@ CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR( param_value_size_ret); } #if defined(CL_ENABLE_LAYERS) -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp( +static cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp( cl_kernel in_kernel, cl_device_id in_device, cl_kernel_sub_group_info param_name, @@ -6742,6 +6808,7 @@ static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp( size_t* param_value_size_ret) { KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(in_kernel->dispatch->clGetKernelSubGroupInfoKHR); return in_kernel->dispatch->clGetKernelSubGroupInfoKHR( in_kernel, in_device, diff --git a/deps/opencl-icd-loader/loader/icd_platform.h b/deps/opencl-icd-loader/loader/icd_platform.h index f84f51955..0f3e43295 100644 --- a/deps/opencl-icd-loader/loader/icd_platform.h +++ b/deps/opencl-icd-loader/loader/icd_platform.h @@ -19,14 +19,16 @@ #ifndef _ICD_PLATFORM_H_ #define _ICD_PLATFORM_H_ -#if defined(__linux__) || defined(__APPLE__) +#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) #define PATH_SEPARATOR ':' #define DIRECTORY_SYMBOL '/' #ifdef __ANDROID__ -#define ICD_VENDOR_PATH "/system/vendor/Khronos/OpenCL/vendors"; +#define ICD_VENDOR_PATH "/system/vendor/Khronos/OpenCL/vendors" +#define LAYER_PATH "/system/vendor/Khronos/OpenCL/layers" #else -#define ICD_VENDOR_PATH "/etc/OpenCL/vendors"; +#define ICD_VENDOR_PATH "/etc/OpenCL/vendors" +#define LAYER_PATH "/etc/OpenCL/layers" #endif // ANDROID #elif defined(_WIN32) @@ -34,6 +36,15 @@ #define PATH_SEPARATOR ';' #define DIRECTORY_SYMBOL '\\' +#else +#error Unknown OS! +#endif + +#ifdef __MINGW32__ +#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0600) +#undef _WIN32_WINNT +#define _WIN32_WINNT 0x0600 #endif +#endif // __MINGW32__ #endif diff --git a/deps/opencl-icd-loader/loader/icd_version.h b/deps/opencl-icd-loader/loader/icd_version.h new file mode 100644 index 000000000..1ecd343b0 --- /dev/null +++ b/deps/opencl-icd-loader/loader/icd_version.h @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2016-2020 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. + * + * OpenCL is a trademark of Apple Inc. used under license by Khronos. + */ + +#ifndef _ICD_VERSION_H_ +#define _ICD_VERSION_H_ + +#define OPENCL_ICD_LOADER_NAME_STRING "Khronos OpenCL ICD Loader" +#define OPENCL_ICD_LOADER_VENDOR_STRING "Khronos Group" + +#define OPENCL_ICD_LOADER_VAL(_v) #_v +#define OPENCL_ICD_LOADER_TOSTRING(_d) OPENCL_ICD_LOADER_VAL(_d) +#define OPENCL_ICD_LOADER_VERSION_STRING \ + OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_MAJOR) "." \ + OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_MINOR) "." \ + OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_REV) + +#if CL_TARGET_OPENCL_VERSION == 100 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "1.0" +#endif +#if CL_TARGET_OPENCL_VERSION == 110 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "1.1" +#endif +#if CL_TARGET_OPENCL_VERSION == 120 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "1.2" +#endif +#if CL_TARGET_OPENCL_VERSION == 200 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "2.0" +#endif +#if CL_TARGET_OPENCL_VERSION == 210 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "2.1" +#endif +#if CL_TARGET_OPENCL_VERSION == 220 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "2.2" +#endif +#if CL_TARGET_OPENCL_VERSION == 300 +#define OPENCL_ICD_LOADER_OCL_VERSION_NUMBER "3.0" +#endif + +#define OPENCL_ICD_LOADER_OCL_VERSION_STRING \ + "OpenCL " OPENCL_ICD_LOADER_OCL_VERSION_NUMBER + +#endif diff --git a/deps/opencl-icd-loader/loader/linux/icd_linux.c b/deps/opencl-icd-loader/loader/linux/icd_linux.c index e404b6f93..265215eba 100644 --- a/deps/opencl-icd-loader/loader/linux/icd_linux.c +++ b/deps/opencl-icd-loader/loader/linux/icd_linux.c @@ -27,6 +27,7 @@ #include #include #include +#include static pthread_once_t initialized = PTHREAD_ONCE_INIT; @@ -36,111 +37,170 @@ static pthread_once_t initialized = PTHREAD_ONCE_INIT; * */ -// go through the list of vendors in the two configuration files -void khrIcdOsVendorsEnumerate(void) +typedef void khrIcdFileAdd(const char *); + +static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char *path, + const char *extension, khrIcdFileAdd addFunc) +{ + struct stat statBuff; + char* fileName = NULL; + + // make sure the file name ends in `extension` (eg. .icd, or .lay) + if (strlen(extension) > strlen(d_name)) + { + return; + } + if (strcmp(d_name + strlen(d_name) - strlen(extension), extension)) + { + return; + } + + // allocate space for the full path of the vendor library name + fileName = malloc(strlen(d_name) + strlen(path) + 2); + if (!fileName) + { + KHR_ICD_TRACE("Failed allocate space for ICD file path\n"); + return; + } + sprintf(fileName, "%s/%s", path, d_name); + + if (stat(fileName, &statBuff)) + { + KHR_ICD_TRACE("Failed stat for: %s, continuing\n", fileName); + free(fileName); + return; + } + + if (S_ISREG(statBuff.st_mode) || S_ISLNK(statBuff.st_mode)) + { + FILE *fin = NULL; + char* buffer = NULL; + long bufferSize = 0; + + // open the file and read its contents + fin = fopen(fileName, "r"); + if (!fin) + { + free(fileName); + return; + } + fseek(fin, 0, SEEK_END); + bufferSize = ftell(fin); + + buffer = malloc(bufferSize+1); + if (!buffer) + { + free(fileName); + fclose(fin); + return; + } + memset(buffer, 0, bufferSize+1); + fseek(fin, 0, SEEK_SET); + if (bufferSize != (long)fread(buffer, 1, bufferSize, fin)) + { + free(fileName); + free(buffer); + fclose(fin); + return; + } + // ignore a newline at the end of the file + if (buffer[bufferSize-1] == '\n') buffer[bufferSize-1] = '\0'; + + // load the string read from the file + addFunc(buffer); + + free(fileName); + free(buffer); + fclose(fin); + } + else + { + KHR_ICD_TRACE("File %s is not a regular file nor symbolic link, continuing\n", fileName); + free(fileName); + } +} + +struct dirElem +{ + char *d_name; + unsigned char d_type; +}; + +static int compareDirElem(const void *a, const void *b) +{ + // sort files the same way libc alpahnumerically sorts directory entries. + return strcoll(((const struct dirElem *)a)->d_name, ((const struct dirElem *)b)->d_name); +} + +static inline void khrIcdOsDirEnumerate(const char *path, const char *env, + const char *extension, + khrIcdFileAdd addFunc, int bSort) { DIR *dir = NULL; - struct dirent *dirEntry = NULL; - const char* vendorPath = ICD_VENDOR_PATH; char* envPath = NULL; - khrIcdVendorsEnumerateEnv(); - - envPath = khrIcd_secure_getenv("OCL_ICD_VENDORS"); + envPath = khrIcd_secure_getenv(env); if (NULL != envPath) { - vendorPath = envPath; + path = envPath; } - dir = opendir(vendorPath); - if (NULL == dir) + dir = opendir(path); + if (NULL == dir) { - KHR_ICD_TRACE("Failed to open path %s, continuing\n", vendorPath); + KHR_ICD_TRACE("Failed to open path %s, continuing\n", path); } else { - // attempt to load all files in the directory - for (dirEntry = readdir(dir); dirEntry; dirEntry = readdir(dir)) - { - struct stat statBuff; - const char* extension = ".icd"; - char* fileName = NULL; - - // make sure the file name ends in .icd - if (strlen(extension) > strlen(dirEntry->d_name)) - { - continue; - } - if (strcmp(dirEntry->d_name + strlen(dirEntry->d_name) - strlen(extension), extension)) - { - continue; - } + struct dirent *dirEntry = NULL; - // allocate space for the full path of the vendor library name - fileName = malloc(strlen(dirEntry->d_name) + strlen(vendorPath) + 2); - if (!fileName) - { - KHR_ICD_TRACE("Failed allocate space for ICD file path\n"); - continue; - } - sprintf(fileName, "%s/%s", vendorPath, dirEntry->d_name); + // attempt to load all files in the directory + if (bSort) { + // store the entries name and type in a buffer for sorting + size_t sz = 0; + size_t elemCount = 0; + size_t elemAlloc = 0; + struct dirElem *dirElems = NULL; + struct dirElem *newDirElems = NULL; + const size_t startupAlloc = 8; - if (stat(fileName, &statBuff)) - { - KHR_ICD_TRACE("Failed stat for: %s, continuing\n", fileName); - free(fileName); - continue; - } + // start with a small buffer + dirElems = (struct dirElem *)malloc(startupAlloc*sizeof(struct dirElem)); + if (NULL != dirElems) { + elemAlloc = startupAlloc; + for (dirEntry = readdir(dir); dirEntry; dirEntry = readdir(dir) ) { + char *nameCopy = NULL; - if (S_ISREG(statBuff.st_mode) || S_ISLNK(statBuff.st_mode)) - { - FILE *fin = NULL; - char* buffer = NULL; - long bufferSize = 0; - - // open the file and read its contents - fin = fopen(fileName, "r"); - if (!fin) - { - free(fileName); - continue; + if (elemCount + 1 > elemAlloc) { + // double buffer size if necessary and possible + if (elemAlloc >= UINT_MAX/2) + break; + newDirElems = (struct dirElem *)realloc(dirElems, elemAlloc*2*sizeof(struct dirElem)); + if (NULL == newDirElems) + break; + dirElems = newDirElems; + elemAlloc *= 2; + } + sz = strlen(dirEntry->d_name) + 1; + nameCopy = (char *)malloc(sz); + if (NULL == nameCopy) + break; + memcpy(nameCopy, dirEntry->d_name, sz); + dirElems[elemCount].d_name = nameCopy; + dirElems[elemCount].d_type = dirEntry->d_type; + elemCount++; } - fseek(fin, 0, SEEK_END); - bufferSize = ftell(fin); - - buffer = malloc(bufferSize+1); - if (!buffer) - { - free(fileName); - fclose(fin); - continue; + qsort(dirElems, elemCount, sizeof(struct dirElem), compareDirElem); + for (struct dirElem *elem = dirElems; elem < dirElems + elemCount; ++elem) { + khrIcdOsDirEntryValidateAndAdd(elem->d_name, path, extension, addFunc); + free(elem->d_name); } - memset(buffer, 0, bufferSize+1); - fseek(fin, 0, SEEK_SET); - if (bufferSize != (long)fread(buffer, 1, bufferSize, fin)) - { - free(fileName); - free(buffer); - fclose(fin); - continue; - } - // ignore a newline at the end of the file - if (buffer[bufferSize-1] == '\n') buffer[bufferSize-1] = '\0'; - - // load the string read from the file - khrIcdVendorAdd(buffer); - - free(fileName); - free(buffer); - fclose(fin); - } - else - { - KHR_ICD_TRACE("File %s is not a regular file nor symbolic link, continuing\n", fileName); - free(fileName); - continue; + free(dirElems); } - } + } else + // use system provided ordering + for (dirEntry = readdir(dir); dirEntry; dirEntry = readdir(dir) ) + khrIcdOsDirEntryValidateAndAdd(dirEntry->d_name, path, extension, addFunc); closedir(dir); } @@ -149,7 +209,20 @@ void khrIcdOsVendorsEnumerate(void) { khrIcd_free_getenv(envPath); } +} + +// go through the list of vendors in the two configuration files +void khrIcdOsVendorsEnumerate(void) +{ + khrIcdInitializeTrace(); + khrIcdVendorsEnumerateEnv(); + + khrIcdOsDirEnumerate(ICD_VENDOR_PATH, "OCL_ICD_VENDORS", ".icd", khrIcdVendorAdd, 0); + #if defined(CL_ENABLE_LAYERS) + // system layers should be closer to the driver + khrIcdOsDirEnumerate(LAYER_PATH, "OPENCL_LAYER_PATH", ".lay", khrIcdLayerAdd, 1); + khrIcdLayersEnumerateEnv(); #endif // defined(CL_ENABLE_LAYERS) } diff --git a/deps/opencl-icd-loader/loader/windows/OpenCL-mingw-i686.def b/deps/opencl-icd-loader/loader/windows/OpenCL-mingw-i686.def new file mode 100644 index 000000000..b7045a0b2 --- /dev/null +++ b/deps/opencl-icd-loader/loader/windows/OpenCL-mingw-i686.def @@ -0,0 +1,162 @@ +; +; 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. +; +; OpenCL is a trademark of Apple Inc. used under license by Khronos. + +EXPORTS + +; +; Note: This is a special .def file that should only be needed for i686 +; (32-bit) mingw builds. In this case we need to export the stdcall- +; decorated functions. In all other cases we can use the standard .def +; file that does not have decorated functions. +; + +; OpenCL 1.0 API +clBuildProgram@24 == clBuildProgram +clCreateBuffer@24 == clCreateBuffer +clCreateCommandQueue@20 == clCreateCommandQueue +clCreateContext@24 == clCreateContext +clCreateContextFromType@24 == clCreateContextFromType +clCreateFromGLBuffer@20 == clCreateFromGLBuffer +clCreateFromGLRenderbuffer@20 == clCreateFromGLRenderbuffer +clCreateFromGLTexture2D@28 == clCreateFromGLTexture2D +clCreateFromGLTexture3D@28 == clCreateFromGLTexture3D +clCreateImage2D@36 == clCreateImage2D +clCreateImage3D@44 == clCreateImage3D +clCreateKernel@12 == clCreateKernel +clCreateKernelsInProgram@16 == clCreateKernelsInProgram +clCreateProgramWithBinary@28 == clCreateProgramWithBinary +clCreateProgramWithSource@20 == clCreateProgramWithSource +clCreateSampler@20 == clCreateSampler +clEnqueueAcquireGLObjects@24 == clEnqueueAcquireGLObjects +clEnqueueBarrier@4 == clEnqueueBarrier +clEnqueueCopyBuffer@36 == clEnqueueCopyBuffer +clEnqueueCopyBufferToImage@36 == clEnqueueCopyBufferToImage +clEnqueueCopyImage@36 == clEnqueueCopyImage +clEnqueueCopyImageToBuffer@36 == clEnqueueCopyImageToBuffer +clEnqueueMapBuffer@44 == clEnqueueMapBuffer +clEnqueueMapImage@52 == clEnqueueMapImage +clEnqueueMarker@8 == clEnqueueMarker +clEnqueueNDRangeKernel@36 == clEnqueueNDRangeKernel +clEnqueueNativeKernel@40 == clEnqueueNativeKernel +clEnqueueReadBuffer@36 == clEnqueueReadBuffer +clEnqueueReadImage@44 == clEnqueueReadImage +clEnqueueReleaseGLObjects@24 == clEnqueueReleaseGLObjects +clEnqueueTask@20 == clEnqueueTask +clEnqueueUnmapMemObject@24 == clEnqueueUnmapMemObject +clEnqueueWaitForEvents@12 == clEnqueueWaitForEvents +clEnqueueWriteBuffer@36 == clEnqueueWriteBuffer +clEnqueueWriteImage@44 == clEnqueueWriteImage +clFinish@4 == clFinish +clFlush@4 == clFlush +clGetCommandQueueInfo@20 == clGetCommandQueueInfo +clGetContextInfo@20 == clGetContextInfo +clGetDeviceIDs@24 == clGetDeviceIDs +clGetDeviceInfo@20 == clGetDeviceInfo +clGetEventInfo@20 == clGetEventInfo +clGetEventProfilingInfo@20 == clGetEventProfilingInfo +clGetExtensionFunctionAddress@4 == clGetExtensionFunctionAddress +clGetGLObjectInfo@12 == clGetGLObjectInfo +clGetGLTextureInfo@20 == clGetGLTextureInfo +clGetImageInfo@20 == clGetImageInfo +clGetKernelInfo@20 == clGetKernelInfo +clGetKernelWorkGroupInfo@24 == clGetKernelWorkGroupInfo +clGetMemObjectInfo@20 == clGetMemObjectInfo +clGetPlatformIDs@12 == clGetPlatformIDs +clGetPlatformInfo@20 == clGetPlatformInfo +clGetProgramBuildInfo@24 == clGetProgramBuildInfo +clGetProgramInfo@20 == clGetProgramInfo +clGetSamplerInfo@20 == clGetSamplerInfo +clGetSupportedImageFormats@28 == clGetSupportedImageFormats +clReleaseCommandQueue@4 == clReleaseCommandQueue +clReleaseContext@4 == clReleaseContext +clReleaseEvent@4 == clReleaseEvent +clReleaseKernel@4 == clReleaseKernel +clReleaseMemObject@4 == clReleaseMemObject +clReleaseProgram@4 == clReleaseProgram +clReleaseSampler@4 == clReleaseSampler +clRetainCommandQueue@4 == clRetainCommandQueue +clRetainContext@4 == clRetainContext +clRetainEvent@4 == clRetainEvent +clRetainKernel@4 == clRetainKernel +clRetainMemObject@4 == clRetainMemObject +clRetainProgram@4 == clRetainProgram +clRetainSampler@4 == clRetainSampler +clSetCommandQueueProperty@20 == clSetCommandQueueProperty +clSetKernelArg@16 == clSetKernelArg +clUnloadCompiler@0 == clUnloadCompiler +clWaitForEvents@8 == clWaitForEvents + +; OpenCL 1.1 API +clCreateSubBuffer@24 == clCreateSubBuffer +clCreateUserEvent@8 == clCreateUserEvent +clEnqueueCopyBufferRect@52 == clEnqueueCopyBufferRect +clEnqueueReadBufferRect@56 == clEnqueueReadBufferRect +clEnqueueWriteBufferRect@56 == clEnqueueWriteBufferRect +clSetEventCallback@16 == clSetEventCallback +clSetMemObjectDestructorCallback@12 == clSetMemObjectDestructorCallback +clSetUserEventStatus@8 == clSetUserEventStatus + +; OpenCL 1.2 API +clCompileProgram@36 == clCompileProgram +clCreateFromGLTexture@28 == clCreateFromGLTexture +clCreateImage@28 == clCreateImage +clCreateProgramWithBuiltInKernels@20 == clCreateProgramWithBuiltInKernels +clCreateSubDevices@20 == clCreateSubDevices +clEnqueueBarrierWithWaitList@16 == clEnqueueBarrierWithWaitList +clEnqueueFillBuffer@36 == clEnqueueFillBuffer +clEnqueueFillImage@32 == clEnqueueFillImage +clEnqueueMarkerWithWaitList@16 == clEnqueueMarkerWithWaitList +clEnqueueMigrateMemObjects@32 == clEnqueueMigrateMemObjects +clGetExtensionFunctionAddressForPlatform@8 == clGetExtensionFunctionAddressForPlatform +clGetKernelArgInfo@24 == clGetKernelArgInfo +clLinkProgram@36 == clLinkProgram +clReleaseDevice@4 == clReleaseDevice +clRetainDevice@4 == clRetainDevice +clUnloadPlatformCompiler@4 == clUnloadPlatformCompiler + +; OpenCL 2.0 API +clCreateCommandQueueWithProperties@16 == clCreateCommandQueueWithProperties +clCreatePipe@28 == clCreatePipe +clCreateSamplerWithProperties@12 == clCreateSamplerWithProperties +clEnqueueSVMFree@32 == clEnqueueSVMFree +clEnqueueSVMMap@36 == clEnqueueSVMMap +clEnqueueSVMMemcpy@32 == clEnqueueSVMMemcpy +clEnqueueSVMMemFill@32 == clEnqueueSVMMemFill +clEnqueueSVMUnmap@20 == clEnqueueSVMUnmap +clGetPipeInfo@20 == clGetPipeInfo +clSetKernelArgSVMPointer@12 == clSetKernelArgSVMPointer +clSetKernelExecInfo@16 == clSetKernelExecInfo +clSVMAlloc@20 == clSVMAlloc +clSVMFree@8 == clSVMFree + +; OpenCL 2.1 API +clCloneKernel@8 == clCloneKernel +clCreateProgramWithIL@16 == clCreateProgramWithIL +clEnqueueSVMMigrateMem@36 == clEnqueueSVMMigrateMem +clGetDeviceAndHostTimer@12 == clGetDeviceAndHostTimer +clGetHostTimer@8 == clGetHostTimer +clGetKernelSubGroupInfo@32 == clGetKernelSubGroupInfo +clSetDefaultDeviceCommandQueue@12 == clSetDefaultDeviceCommandQueue + +; OpenCL 2.2 API +clSetProgramReleaseCallback@12 == clSetProgramReleaseCallback +clSetProgramSpecializationConstant@16 == clSetProgramSpecializationConstant + +; OpenCL 3.0 API +clCreateBufferWithProperties@28 == clCreateBufferWithProperties +clCreateImageWithProperties@32 == clCreateImageWithProperties +clSetContextDestructorCallback@12 == clSetContextDestructorCallback diff --git a/deps/opencl-icd-loader/loader/windows/OpenCL.rc b/deps/opencl-icd-loader/loader/windows/OpenCL.rc index b1ddf5006..7c44cd4b3 100644 --- a/deps/opencl-icd-loader/loader/windows/OpenCL.rc +++ b/deps/opencl-icd-loader/loader/windows/OpenCL.rc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2020 The Khronos Group Inc. + * Copyright (c) 2016-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. @@ -17,20 +17,10 @@ */ #include - -#define OPENCL_ICD_LOADER_VERSION_MAJOR 3 -#define OPENCL_ICD_LOADER_VERSION_MINOR 0 -#define OPENCL_ICD_LOADER_VERSION_REV 3 +#include #ifdef RC_INVOKED -#define OPENCL_ICD_LOADER_VAL(_v) #_v -#define OPENCL_ICD_LOADER_TOSTRING(_d) OPENCL_ICD_LOADER_VAL(_d) -#define OPENCL_ICD_LOADER_VERSION_STRING \ - OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_MAJOR) "." \ - OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_MINOR) "." \ - OPENCL_ICD_LOADER_TOSTRING(OPENCL_ICD_LOADER_VERSION_REV) - VS_VERSION_INFO VERSIONINFO FILEVERSION OPENCL_ICD_LOADER_VERSION_MAJOR,OPENCL_ICD_LOADER_VERSION_MINOR,OPENCL_ICD_LOADER_VERSION_REV,0 PRODUCTVERSION OPENCL_ICD_LOADER_VERSION_MAJOR,OPENCL_ICD_LOADER_VERSION_MINOR,OPENCL_ICD_LOADER_VERSION_REV,0 @@ -42,10 +32,10 @@ BEGIN BLOCK "040904E4" BEGIN VALUE "FileDescription" ,"OpenCL Client DLL" - VALUE "ProductName" ,"Khronos OpenCL ICD Loader" - VALUE "LegalCopyright" ,"Copyright \251 The Khronos Group Inc 2016-2020" + VALUE "ProductName" ,OPENCL_ICD_LOADER_NAME_STRING + VALUE "LegalCopyright" ,L"Copyright \251 The Khronos Group Inc 2016-2023" VALUE "FileVersion" ,OPENCL_ICD_LOADER_VERSION_STRING ".0" - VALUE "CompanyName" ,"Khronos Group" + VALUE "CompanyName" ,OPENCL_ICD_LOADER_VENDOR_STRING VALUE "InternalName" ,"OpenCL" VALUE "OriginalFilename","OpenCL.dll" END diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows.c b/deps/opencl-icd-loader/loader/windows/icd_windows.c index f26cfe511..44a8a98fb 100644 --- a/deps/opencl-icd-loader/loader/windows/icd_windows.c +++ b/deps/opencl-icd-loader/loader/windows/icd_windows.c @@ -24,6 +24,7 @@ #include "icd_windows_dxgk.h" #include "icd_windows_apppackage.h" #include +#include #include #include @@ -97,6 +98,83 @@ void adapterFree(WinAdapter *pWinAdapter) pWinAdapter->szName = NULL; } +#if defined(CL_ENABLE_LAYERS) +typedef struct WinLayer +{ + char * szName; + DWORD priority; +} WinLayer; + +static WinLayer* pWinLayerBegin; +static WinLayer* pWinLayerEnd; +static WinLayer* pWinLayerCapacity; + +static int __cdecl compareLayer(const void *a, const void *b) +{ + return ((WinLayer *)a)->priority < ((WinLayer *)b)->priority ? -1 : + ((WinLayer *)a)->priority > ((WinLayer *)b)->priority ? 1 : 0; +} + +static BOOL layerAdd(const char* szName, DWORD priority) +{ + BOOL result = TRUE; + if (pWinLayerEnd == pWinLayerCapacity) + { + size_t oldCapacity = pWinLayerCapacity - pWinLayerBegin; + size_t newCapacity = oldCapacity; + if (0 == newCapacity) + { + newCapacity = 1; + } + else if(newCapacity < UINT_MAX/2) + { + newCapacity *= 2; + } + + WinLayer* pNewBegin = malloc(newCapacity * sizeof(*pWinLayerBegin)); + if (!pNewBegin) + { + KHR_ICD_TRACE("Failed allocate space for Layers array\n"); + result = FALSE; + } + else + { + if (pWinLayerBegin) + { + memcpy(pNewBegin, pWinLayerBegin, oldCapacity * sizeof(*pWinLayerBegin)); + free(pWinLayerBegin); + } + pWinLayerCapacity = pNewBegin + newCapacity; + pWinLayerEnd = pNewBegin + oldCapacity; + pWinLayerBegin = pNewBegin; + } + } + if (pWinLayerEnd != pWinLayerCapacity) + { + size_t nameLen = (strlen(szName) + 1)*sizeof(szName[0]); + pWinLayerEnd->szName = malloc(nameLen); + if (!pWinLayerEnd->szName) + { + KHR_ICD_TRACE("Failed allocate space for Layer file path\n"); + result = FALSE; + } + else + { + memcpy(pWinLayerEnd->szName, szName, nameLen); + pWinLayerEnd->priority = priority; + ++pWinLayerEnd; + } + } + return result; +} + +void layerFree(WinLayer *pWinLayer) +{ + free(pWinLayer->szName); + pWinLayer->szName = NULL; +} +#endif // defined(CL_ENABLE_LAYERS) + /* * * Vendor enumeration functions @@ -107,12 +185,17 @@ void adapterFree(WinAdapter *pWinAdapter) // for each vendor encountered BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext) { + (void)InitOnce; + (void)Parameter; + (void)lpContext; + LONG result; BOOL status = FALSE, currentStatus = FALSE; const char* platformsName = "SOFTWARE\\Khronos\\OpenCL\\Vendors"; HKEY platformsKey = NULL; DWORD dwIndex; + khrIcdInitializeTrace(); khrIcdVendorsEnumerateEnv(); currentStatus = khrIcdOsVendorsEnumerateDXGK(); @@ -194,7 +277,7 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO } // Add adapters according to DXGI's preference order - HMODULE hDXGI = LoadLibrary("dxgi.dll"); + HMODULE hDXGI = LoadLibraryA("dxgi.dll"); if (hDXGI) { IDXGIFactory* pFactory = NULL; @@ -247,7 +330,76 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO { KHR_ICD_TRACE("Failed to close platforms key %s, ignoring\n", platformsName); } + #if defined(CL_ENABLE_LAYERS) + const char* layersName = "SOFTWARE\\Khronos\\OpenCL\\Layers"; + HKEY layersKey = NULL; + + KHR_ICD_TRACE("Opening key HKLM\\%s...\n", layersName); + result = RegOpenKeyExA( + HKEY_LOCAL_MACHINE, + layersName, + 0, + KEY_READ, + &layersKey); + if (ERROR_SUCCESS != result) + { + KHR_ICD_TRACE("Failed to open layers key %s, continuing\n", layersName); + } + else + { + // for each value + for (dwIndex = 0;; ++dwIndex) + { + char cszLibraryName[1024] = {0}; + DWORD dwLibraryNameSize = sizeof(cszLibraryName); + DWORD dwLibraryNameType = 0; + DWORD dwValue = 0; + DWORD dwValueSize = sizeof(dwValue); + + // read the value name + KHR_ICD_TRACE("Reading value %"PRIuDW"...\n", dwIndex); + result = RegEnumValueA( + layersKey, + dwIndex, + cszLibraryName, + &dwLibraryNameSize, + NULL, + &dwLibraryNameType, + (LPBYTE)&dwValue, + &dwValueSize); + // if RegEnumKeyEx fails, we are done with the enumeration + if (ERROR_SUCCESS != result) + { + KHR_ICD_TRACE("Failed to read value %"PRIuDW", done reading key.\n", dwIndex); + break; + } + KHR_ICD_TRACE("Value %s found...\n", cszLibraryName); + + // Require that the value be a DWORD + if (REG_DWORD != dwLibraryNameType) + { + KHR_ICD_TRACE("Value not a DWORD, skipping\n"); + continue; + } + // add the library + status |= layerAdd(cszLibraryName, dwValue); + } + qsort(pWinLayerBegin, pWinLayerEnd - pWinLayerBegin, sizeof(WinLayer), compareLayer); + for (WinLayer* iterLayer = pWinLayerBegin; iterLayer != pWinLayerEnd; ++iterLayer) + { + khrIcdLayerAdd(iterLayer->szName); + layerFree(iterLayer); + } + } + + free(pWinLayerBegin); + pWinLayerBegin = NULL; + pWinLayerEnd = NULL; + pWinLayerCapacity = NULL; + + result = RegCloseKey(layersKey); + khrIcdLayersEnumerateEnv(); #endif // defined(CL_ENABLE_LAYERS) return status; @@ -275,7 +427,7 @@ void *khrIcdOsLibraryLoad(const char *libraryName) } if (!hTemp) { - KHR_ICD_TRACE("Failed to load driver. Windows error code is %d.\n", GetLastError()); + KHR_ICD_TRACE("Failed to load driver. Windows error code is %"PRIuDW".\n", GetLastError()); } return (void*)hTemp; } diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.c b/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.c new file mode 100644 index 000000000..d9571551b --- /dev/null +++ b/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.c @@ -0,0 +1,123 @@ +/* + * 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. + * + * OpenCL is a trademark of Apple Inc. used under license by Khronos. + */ + +#include +#include "icd_windows_apppackage.h" + +typedef _Check_return_ LONG(WINAPI *PFN_GetPackagesByPackageFamily)( + _In_ PCWSTR packageFamilyName, + _Inout_ UINT32* count, + _Out_writes_opt_(*count) PWSTR* packageFullNames, + _Inout_ UINT32* bufferLength, + _Out_writes_opt_(*bufferLength) WCHAR* buffer + ); + +typedef LONG (WINAPI *PFN_GetPackagePathByFullName)( + _In_ PCWSTR packageFullName, + _Inout_ UINT32* pathLength, + _Out_writes_opt_(*pathLength) PWSTR path + ); + +bool khrIcdOsVendorsEnumerateAppPackage(void) +{ + bool ret = false; + WCHAR *buffer = NULL; + PWSTR *packages = NULL; + + HMODULE h = LoadLibraryA("kernel32.dll"); + if (h == NULL) + return ret; + + PFN_GetPackagesByPackageFamily pGetPackagesByPackageFamily = + (PFN_GetPackagesByPackageFamily)GetProcAddress(h, "GetPackagesByPackageFamily"); + if (!pGetPackagesByPackageFamily) + { + KHR_ICD_TRACE("GetProcAddress failed for GetPackagesByPackageFamily\n"); + goto cleanup; + } + + PFN_GetPackagePathByFullName pGetPackagePathByFullName = + (PFN_GetPackagePathByFullName)GetProcAddress(h, "GetPackagePathByFullName"); + if (!pGetPackagePathByFullName) + { + KHR_ICD_TRACE("GetProcAddress failed for GetPackagePathByFullName\n"); + goto cleanup; + } + + UINT32 numPackages = 0, bufferLength = 0; + PCWSTR familyName = L"Microsoft.D3DMappingLayers_8wekyb3d8bbwe"; + if (ERROR_INSUFFICIENT_BUFFER != pGetPackagesByPackageFamily(familyName, + &numPackages, NULL, + &bufferLength, NULL) || + numPackages == 0 || bufferLength == 0) + { + KHR_ICD_TRACE("Failed to find mapping layers packages by family name\n"); + goto cleanup; + } + + buffer = malloc(sizeof(WCHAR) * bufferLength); + packages = malloc(sizeof(PWSTR) * numPackages); + if (!buffer || !packages) + { + KHR_ICD_TRACE("Failed to allocate memory for package names\n"); + goto cleanup; + } + + if (ERROR_SUCCESS != pGetPackagesByPackageFamily(familyName, + &numPackages, packages, + &bufferLength, buffer)) + { + KHR_ICD_TRACE("Failed to get mapping layers package full names\n"); + goto cleanup; + } + + UINT32 pathLength = 0; + WCHAR path[MAX_PATH]; + if (ERROR_INSUFFICIENT_BUFFER != pGetPackagePathByFullName(packages[0], &pathLength, NULL) || + pathLength > MAX_PATH || + ERROR_SUCCESS != pGetPackagePathByFullName(packages[0], &pathLength, path)) + { + KHR_ICD_TRACE("Failed to get mapping layers package path length\n"); + goto cleanup; + } + +#if defined(_M_AMD64) +#define PLATFORM_PATH L"x64" +#elif defined(_M_ARM) +#define PLATFORM_PATH L"arm" +#elif defined(_M_ARM64) +#define PLATFORM_PATH L"arm64" +#elif defined(_M_IX86) +#define PLATFORM_PATH L"x86" +#endif + + wchar_t dllPath[MAX_PATH]; + wcscpy_s(dllPath, MAX_PATH, path); + wcscat_s(dllPath, MAX_PATH, L"\\" PLATFORM_PATH L"\\OpenCLOn12.dll"); + + char narrowDllPath[MAX_PATH]; + WideCharToMultiByte(CP_UTF8, 0, dllPath, -1, narrowDllPath, MAX_PATH, NULL, NULL); + + ret = adapterAdd(narrowDllPath, ZeroLuid); + +cleanup: + FreeLibrary(h); + free(buffer); + free(packages); + return ret; +} diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.cpp b/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.cpp deleted file mode 100644 index b305c5dbe..000000000 --- a/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.cpp +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (c) 2017-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. - * - * OpenCL is a trademark of Apple Inc. used under license by Khronos. - */ - -#include "icd.h" -#include "icd_windows.h" - -#ifdef OPENCL_ICD_LOADER_DISABLE_OPENCLON12 - -extern "C" bool khrIcdOsVendorsEnumerateAppPackage() -{ - KHR_ICD_TRACE("OpenCLOn12 is disabled\n"); - return false; -} - -#else - -#include "icd_windows_apppackage.h" - -#include -#include -#include - -#include -#include - -template -struct ScopeExit { - ScopeExit(F&& f) : f(std::forward(f)) {} - ~ScopeExit() { f(); } - F f; -}; - -template -inline ScopeExit MakeScopeExit(F&& f) { - return ScopeExit(std::forward(f)); -}; - -using namespace Microsoft::WRL; -using namespace Microsoft::WRL::Wrappers; - -extern "C" bool khrIcdOsVendorsEnumerateAppPackage() -{ - HRESULT hrInit = Windows::Foundation::Initialize(RO_INIT_MULTITHREADED); - if (hrInit == RPC_E_CHANGED_MODE) - { - hrInit = Windows::Foundation::Initialize(RO_INIT_SINGLETHREADED); - } - if (FAILED(hrInit)) - { - KHR_ICD_TRACE("Failed to init WinRT\n"); - return false; - } - auto Cleanup = MakeScopeExit([]() - { - Windows::Foundation::Uninitialize(); - }); - - using ABI::Windows::Management::Deployment::IPackageManager; - ComPtr packageManager; - if (FAILED(Windows::Foundation::ActivateInstance( - HStringReference(RuntimeClass_Windows_Management_Deployment_PackageManager).Get(), - &packageManager))) - { - KHR_ICD_TRACE("Failed to get package manager\n"); - return false; - } - - using IPackageCollection = ABI::Windows::Foundation::Collections::__FIIterable_1_Windows__CApplicationModel__CPackage_t; - ComPtr collection; - if (FAILED(packageManager->FindPackagesByUserSecurityIdPackageFamilyName( - HStringReference(L"").Get(), - HStringReference(L"Microsoft.D3DMappingLayers_8wekyb3d8bbwe").Get(), - &collection))) - { - KHR_ICD_TRACE("Failed to find mapping layers package\n"); - return false; - } - - using IPackageIterator = ABI::Windows::Foundation::Collections::IIterator< - ABI::Windows::ApplicationModel::Package*>; - ComPtr iter; - if (FAILED(collection->First(&iter))) - { - KHR_ICD_TRACE("Failed to get package collection iterator\n"); - return false; - } - - while ([&iter]() - { - boolean hasCurrent = false; - return SUCCEEDED(iter->get_HasCurrent(&hasCurrent)) && hasCurrent; - }()) - { - using ABI::Windows::ApplicationModel::IPackage; - ComPtr package; - if (FAILED(iter->get_Current(&package))) - { - KHR_ICD_TRACE("Failed to get package\n"); - boolean hasCurrent = false; - (void)iter->MoveNext(&hasCurrent); - continue; - } - - boolean hasCurrent = false; - (void)iter->MoveNext(&hasCurrent); - - using ABI::Windows::Storage::IStorageFolder; - ComPtr folder; - if (FAILED(package->get_InstalledLocation(&folder))) - { - KHR_ICD_TRACE("Failed to get package install folder\n"); - continue; - } - - using ABI::Windows::Storage::IStorageItem; - ComPtr item; - if (FAILED(folder.As(&item))) - { - KHR_ICD_TRACE("Failed to convert folder to storage item\n"); - continue; - } - - HString path; - if (FAILED(item->get_Path(path.GetAddressOf()))) - { - KHR_ICD_TRACE("Failed to get path\n"); - continue; - } - - UINT pathSize = 0; - auto rawPath = path.GetRawBuffer(&pathSize); - if (pathSize == 0 || rawPath == nullptr) - { - KHR_ICD_TRACE("Failed to get path\n"); - continue; - } - -#if defined(_M_AMD64) -#define PLATFORM_PATH L"x64" -#elif defined(_M_ARM) -#define PLATFORM_PATH L"arm" -#elif defined(_M_ARM64) -#define PLATFORM_PATH L"arm64" -#elif defined(_M_IX86) -#define PLATFORM_PATH L"x86" -#endif - - wchar_t dllPath[MAX_PATH]; - wcscpy_s(dllPath, rawPath); - wcscat_s(dllPath, L"\\" PLATFORM_PATH L"\\OpenCLOn12.dll"); - - std::wstring_convert> convert; - std::string narrowDllPath = convert.to_bytes(dllPath); - - adapterAdd(narrowDllPath.c_str(), {}); - return true; - } - return false; -} - -#endif diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.h b/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.h index d4c55da32..5419ad454 100644 --- a/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.h +++ b/deps/opencl-icd-loader/loader/windows/icd_windows_apppackage.h @@ -19,7 +19,4 @@ #include #include "icd_windows.h" -#ifdef __cplusplus -extern "C" -#endif bool khrIcdOsVendorsEnumerateAppPackage(void); diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows_dxgk.c b/deps/opencl-icd-loader/loader/windows/icd_windows_dxgk.c index 5dc985c60..a610b9b5c 100644 --- a/deps/opencl-icd-loader/loader/windows/icd_windows_dxgk.c +++ b/deps/opencl-icd-loader/loader/windows/icd_windows_dxgk.c @@ -35,7 +35,7 @@ bool khrIcdOsVendorsEnumerateDXGK(void) int result = 0; // Get handle to GDI Runtime - HMODULE h = LoadLibrary("gdi32.dll"); + HMODULE h = LoadLibraryA("gdi32.dll"); if (h == NULL) return ret; @@ -44,7 +44,6 @@ bool khrIcdOsVendorsEnumerateDXGK(void) LoaderEnumAdapters2 EnumAdapters; NTSTATUS status = STATUS_SUCCESS; - char cszLibraryName[MAX_PATH] = { 0 }; EnumAdapters.adapter_count = 0; EnumAdapters.adapters = NULL; PFN_LoaderEnumAdapters2 pEnumAdapters2 = (PFN_LoaderEnumAdapters2)GetProcAddress(h, "D3DKMTEnumAdapters2"); @@ -99,7 +98,7 @@ bool khrIcdOsVendorsEnumerateDXGK(void) queryArgs.query_flags.translate_path = TRUE; queryArgs.value_type = REG_SZ; result = MultiByteToWideChar( - CP_ACP, + CP_UTF8, 0, cszOpenCLRegKeyName, szOpenCLRegKeyName, @@ -146,12 +145,22 @@ bool khrIcdOsVendorsEnumerateDXGK(void) } if (NT_SUCCESS(status) && pQueryArgs->status == LOADER_QUERY_REGISTRY_STATUS_SUCCESS) { - wchar_t* pWchar = pQueryArgs->output_string; - memset(cszLibraryName, 0, sizeof(cszLibraryName)); + char cszLibraryName[MAX_PATH]; + result = WideCharToMultiByte( + CP_UTF8, + 0, + pQueryArgs->output_string, + -1, + cszLibraryName, + MAX_PATH, + NULL, + NULL); + if (!result) + { + KHR_ICD_TRACE("WideCharToMultiByte status != SUCCESS\n"); + } + else { - size_t len; - wcstombs_s(&len, cszLibraryName, sizeof(cszLibraryName), pWchar, sizeof(cszLibraryName)); - KHR_ICD_ASSERT(len == (sizeof(cszLibraryName) - 1)); ret |= adapterAdd(cszLibraryName, EnumAdapters.adapters[AdapterIndex].luid); } } diff --git a/deps/opencl-icd-loader/loader/windows/icd_windows_hkr.c b/deps/opencl-icd-loader/loader/windows/icd_windows_hkr.c index 96176ab52..ae4ba163a 100644 --- a/deps/opencl-icd-loader/loader/windows/icd_windows_hkr.c +++ b/deps/opencl-icd-loader/loader/windows/icd_windows_hkr.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2019 The Khronos Group Inc. + * 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. @@ -214,8 +214,12 @@ bool khrIcdOsVendorsEnumerateHKR(void) ULONG szBuffer = 0; OLECHAR display_adapter_guid_str[MAX_GUID_STRING_LEN]; +#if defined(CM_GETIDLIST_FILTER_CLASS) && defined(CM_GETIDLIST_FILTER_PRESENT) ULONG ulFlags = CM_GETIDLIST_FILTER_CLASS | CM_GETIDLIST_FILTER_PRESENT; +#else + ULONG ulFlags = 0x300; +#endif iret = StringFromGUID2( &GUID_DEVCLASS_DISPLAY, @@ -275,8 +279,6 @@ bool khrIcdOsVendorsEnumerateHKR(void) for (PWSTR deviceId = deviceIdList; *deviceId; deviceId += wcslen(deviceId) + 1) { - DEVPROPTYPE devpropType; - KHR_ICD_WIDE_TRACE(L"Device ID: %ls\n", deviceId); ret = CM_Locate_DevNodeW(&devinst, deviceId, 0); @@ -338,17 +340,22 @@ bool khrIcdOsVendorsEnumerateHKR(void) KHR_ICD_WIDE_TRACE(L" deviceInstanceID: %ls\n", deviceInstanceID); } - ret = CM_Get_DevNode_PropertyW( + ret = CM_Get_DevNode_Registry_PropertyW( devchild, - &DEVPKEY_Device_ClassGuid, - &devpropType, + CM_DRP_CLASSGUID, + NULL, (PBYTE)&guid, &szGuid, 0); - if (CR_SUCCESS != ret || - !IsEqualGUID(&OCL_GUID_DEVCLASS_SOFTWARECOMPONENT, &guid)) + if (CR_SUCCESS != ret) + { + KHR_ICD_TRACE(" CM_Get_DevNode_Registry_PropertyW returned 0x%"PRIxDW", skipping device...\n", ret); + continue; + } + else if (!IsEqualGUID(&OCL_GUID_DEVCLASS_SOFTWARECOMPONENT, &guid)) { + KHR_ICD_TRACE(" GUID does not match, skipping device...\n"); continue; } diff --git a/deps/opencl-icd-loader/scripts/icd_dispatch_generated.c.mako b/deps/opencl-icd-loader/scripts/icd_dispatch_generated.c.mako index d37282f30..05a26fc53 100644 --- a/deps/opencl-icd-loader/scripts/icd_dispatch_generated.c.mako +++ b/deps/opencl-icd-loader/scripts/icd_dispatch_generated.c.mako @@ -23,7 +23,7 @@ apihandles = { 'cl_sampler' : 'CL_INVALID_SAMPLER', } %>/* - * Copyright (c) 2012-2020 The Khronos Group Inc. + * Copyright (c) 2012-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. @@ -40,8 +40,8 @@ apihandles = { * OpenCL is a trademark of Apple Inc. used under license by Khronos. */ -#include "icd_dispatch.h" #include "icd.h" +#include "icd_dispatch.h" #ifdef __cplusplus extern "C" { @@ -63,7 +63,7 @@ extern "C" { % if disp == 1: #if defined(CL_ENABLE_LAYERS) % endif -${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}( +${("CL_API_ENTRY", "static")[disp]} ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}( %for i, param in enumerate(api.Params): % if i < len(api.Params)-1: ${param.Type} ${param.Name}${param.TypeEnd}, @@ -162,7 +162,7 @@ ${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("" %endfor %else: #if defined(CL_ENABLE_LAYERS) -extern CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_disp"}( +extern ${api.RetType} CL_API_CALL ${api.Name + "_disp"}( %for i, param in enumerate(api.Params): % if i < len(api.Params)-1: ${param.Type} ${param.Name}${param.TypeEnd}, @@ -171,7 +171,6 @@ extern CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_disp"}( % endif %endfor #endif // defined(CL_ENABLE_LAYERS) - %endif %endfor %endfor @@ -213,7 +212,7 @@ win32extensions = { % if disp == 1: #if defined(CL_ENABLE_LAYERS) % endif -${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}( +${("CL_API_ENTRY", "static")[disp]} ${api.RetType} CL_API_CALL ${api.Name + ("", "_disp")[disp]}( %for i, param in enumerate(api.Params): % if i < len(api.Params)-1: ${param.Type} ${param.Name}${param.TypeEnd}, @@ -240,14 +239,17 @@ ${("", "static ")[disp]}CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + ("" // api.Name == "clXXX": # There are currently no API special cases here. % else: KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${handle.Name}, ${invalid}); + KHR_ICD_VALIDATE_POINTER_RETURN_HANDLE(${handle.Name}->dispatch->${api.Name}); % endif %else: % if api.Name == "clGetGLContextInfoKHR": cl_platform_id platform = NULL; khrIcdContextPropertiesGetPlatform(properties, &platform); KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(platform->dispatch->${api.Name}); % else: KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, ${invalid}); + KHR_ICD_VALIDATE_POINTER_RETURN_ERROR(${handle.Name}->dispatch->${api.Name}); % endif %endif %if api.Name == "clGetGLContextInfoKHR": diff --git a/deps/opencl-icd-loader/scripts/icd_print_layer_generated.c.mako b/deps/opencl-icd-loader/scripts/icd_print_layer_generated.c.mako index 4cfd78442..3ef38d538 100644 --- a/deps/opencl-icd-loader/scripts/icd_print_layer_generated.c.mako +++ b/deps/opencl-icd-loader/scripts/icd_print_layer_generated.c.mako @@ -22,7 +22,7 @@ // Core APIs: %for apis in coreapis.values(): %for api in apis: -static CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}( +static ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}( %for i, param in enumerate(api.Params): % if i < len(api.Params)-1: ${param.Type} ${param.Name}${param.TypeEnd}, @@ -76,7 +76,7 @@ win32extensions = { #if defined(_WIN32) %endif %for api in apis: -static CL_API_ENTRY ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}( +static ${api.RetType} CL_API_CALL ${api.Name + "_wrap"}( %for i, param in enumerate(api.Params): % if i < len(api.Params)-1: ${param.Type} ${param.Name}${param.TypeEnd}, diff --git a/deps/opencl-icd-loader/test/CMakeLists.txt b/deps/opencl-icd-loader/test/CMakeLists.txt index bf720ea7d..0d78a79f1 100644 --- a/deps/opencl-icd-loader/test/CMakeLists.txt +++ b/deps/opencl-icd-loader/test/CMakeLists.txt @@ -18,17 +18,30 @@ add_test ( NAME opencl_icd_loader_test COMMAND icd_loader_test ) -get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) -if(GENERATOR_IS_MULTI_CONFIG) - set_tests_properties(opencl_icd_loader_test - PROPERTIES - ENVIRONMENT OCL_ICD_FILENAMES=$ - WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/$" + +if (ENABLE_OPENCL_LAYERINFO) + add_test ( + NAME cllayerinfo_test + COMMAND cllayerinfo ) -else() - set_tests_properties(opencl_icd_loader_test +endif () + +get_property(GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if (GENERATOR_IS_MULTI_CONFIG) + set (TEST_WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/$") +else () + set (TEST_WORKING_DIRECTORY "${CMAKE_BINARY_DIR}") +endif() + +set_tests_properties(opencl_icd_loader_test + PROPERTIES + ENVIRONMENT OCL_ICD_FILENAMES=$ + WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" +) +if (ENABLE_OPENCL_LAYERINFO) + set_tests_properties(cllayerinfo_test PROPERTIES - ENVIRONMENT OCL_ICD_FILENAMES=$ - WORKING_DIRECTORY "${CMAKE_BINARY_DIR}" + ENVIRONMENT OPENCL_LAYERS=$ + WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" ) endif() diff --git a/deps/opencl-icd-loader/test/driver_stub/cl.c b/deps/opencl-icd-loader/test/driver_stub/cl.c index 9b78e5804..ba37a8514 100644 --- a/deps/opencl-icd-loader/test/driver_stub/cl.c +++ b/deps/opencl-icd-loader/test/driver_stub/cl.c @@ -93,11 +93,9 @@ clGetPlatformIDs(cl_uint num_entries , } CL_API_ENTRY cl_int CL_API_CALL -clGetPlatformInfo(cl_platform_id platform, - cl_platform_info param_name, - size_t param_value_size, - void * param_value, - size_t * param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 +clGetPlatformInfo(cl_platform_id platform_id, cl_platform_info param_name, + size_t param_value_size, void *param_value, + size_t *param_value_size_ret) CL_API_SUFFIX__VERSION_1_0 { cl_int ret = CL_SUCCESS; const char *returnString = NULL; @@ -116,23 +114,15 @@ clGetPlatformInfo(cl_platform_id platform, } // select the string to return switch(param_name) { - case CL_PLATFORM_PROFILE: - returnString = platform->profile; - break; - case CL_PLATFORM_VERSION: - returnString = platform->version; - break; - case CL_PLATFORM_NAME: - returnString = platform->name; - break; - case CL_PLATFORM_VENDOR: - returnString = platform->vendor; - break; + case CL_PLATFORM_PROFILE: returnString = platform_id->profile; break; + case CL_PLATFORM_VERSION: returnString = platform_id->version; break; + case CL_PLATFORM_NAME: returnString = platform_id->name; break; + case CL_PLATFORM_VENDOR: returnString = platform_id->vendor; break; case CL_PLATFORM_EXTENSIONS: - returnString = platform->extensions; + returnString = platform_id->extensions; break; case CL_PLATFORM_ICD_SUFFIX_KHR: - returnString = platform->suffix; + returnString = platform_id->suffix; break; default: ret = CL_INVALID_VALUE; @@ -162,12 +152,9 @@ clGetPlatformInfo(cl_platform_id platform, /* Device APIs */ -CL_API_ENTRY cl_int CL_API_CALL -clGetDeviceIDs(cl_platform_id platform, - cl_device_type device_type, - cl_uint num_entries, - cl_device_id * devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_0 +CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs( + cl_platform_id platform_id, cl_device_type device_type, cl_uint num_entries, + cl_device_id *devices, cl_uint *num_devices) CL_API_SUFFIX__VERSION_1_0 { cl_int ret = CL_SUCCESS; @@ -186,12 +173,8 @@ clGetDeviceIDs(cl_platform_id platform, } done: - test_icd_stub_log("clGetDeviceIDs(%p, %x, %u, %p, %p)\n", - platform, - device_type, - num_entries, - devices, - num_devices); + test_icd_stub_log("clGetDeviceIDs(%p, %x, %u, %p, %p)\n", platform_id, + device_type, num_entries, devices, num_devices); test_icd_stub_log("Value returned: %d\n", ret); return ret; } @@ -950,10 +933,10 @@ clLinkProgram(cl_context context , CL_API_ENTRY cl_int CL_API_CALL -clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 +clUnloadPlatformCompiler(cl_platform_id platform_id) CL_API_SUFFIX__VERSION_1_2 { cl_int return_value = CL_OUT_OF_RESOURCES; - test_icd_stub_log("clUnloadPlatformCompiler(%p)\n", platform); + test_icd_stub_log("clUnloadPlatformCompiler(%p)\n", platform_id); test_icd_stub_log("Value returned: %d\n", return_value); return return_value; } @@ -1835,14 +1818,15 @@ clEnqueueNativeKernel(cl_command_queue command_queue , return return_value; } -CL_API_ENTRY void * CL_API_CALL -clGetExtensionFunctionAddressForPlatform(cl_platform_id platform , - const char * func_name) CL_API_SUFFIX__VERSION_1_2 +static void extFunc(void) { } + +CL_API_ENTRY void *CL_API_CALL clGetExtensionFunctionAddressForPlatform( + cl_platform_id platform_id, + const char *func_name) CL_API_SUFFIX__VERSION_1_2 { - void *return_value = (void *) malloc(sizeof(void *)); + void *return_value = (void *)(size_t)&extFunc; test_icd_stub_log("clGetExtensionFunctionAddressForPlatform(%p, %p)\n", - platform, - func_name); + platform_id, func_name); test_icd_stub_log("Value returned: %p\n", return_value); return return_value; diff --git a/deps/opencl-icd-loader/test/inc/platform/icd_test_log.h b/deps/opencl-icd-loader/test/inc/platform/icd_test_log.h index 6db0bfe6a..1847ef384 100644 --- a/deps/opencl-icd-loader/test/inc/platform/icd_test_log.h +++ b/deps/opencl-icd-loader/test/inc/platform/icd_test_log.h @@ -1,10 +1,18 @@ #ifndef _ICD_TEST_LOG_H_ #define _ICD_TEST_LOG_H_ -#if defined (_WIN32) -#define DllExport __declspec( dllexport ) +#if defined(_WIN32) || defined(__CYGWIN__) + #define DllExport __declspec(dllexport) #else -#define DllExport + #ifndef __has_attribute + #define __has_attribute(x) 0 // Compatibility with non-clang compilers. + #endif + #if (defined(__GNUC__) && (__GNUC__ >= 4)) ||\ + (defined(__clang__) && __has_attribute(visibility)) + #define DllExport __attribute__((visibility("default"))) + #else + #define DllExport + #endif #endif DllExport int test_icd_initialize_app_log(void); diff --git a/deps/opencl-icd-loader/test/layer/icd_print_layer.c b/deps/opencl-icd-loader/test/layer/icd_print_layer.c index 06525bfad..d8bf46274 100644 --- a/deps/opencl-icd-loader/test/layer/icd_print_layer.c +++ b/deps/opencl-icd-loader/test/layer/icd_print_layer.c @@ -17,34 +17,58 @@ */ #include "icd_print_layer.h" +#include +#include +#include struct _cl_icd_dispatch dispatch; const struct _cl_icd_dispatch *tdispatch; +static cl_layer_api_version api_version = CL_LAYER_API_VERSION_100; +static const char name[] = "print_layer"; + +static inline cl_int +set_param_value( + size_t param_value_size, + void *param_value, + size_t *param_value_size_ret, + size_t src_size, + const void *src) { + if (param_value && param_value_size < src_size) + return CL_INVALID_VALUE; + if (param_value) + memcpy(param_value, src, src_size); + if (param_value_size_ret) + *param_value_size_ret = src_size; + return CL_SUCCESS; +} + CL_API_ENTRY cl_int CL_API_CALL clGetLayerInfo( cl_layer_info param_name, size_t param_value_size, void *param_value, size_t *param_value_size_ret) { + size_t sz = 0; + const void *src = NULL; if (param_value_size && !param_value) return CL_INVALID_VALUE; if (!param_value && !param_value_size_ret) return CL_INVALID_VALUE; switch (param_name) { case CL_LAYER_API_VERSION: - if (param_value_size < sizeof(cl_layer_api_version)) - return CL_INVALID_VALUE; - if (param_value) - *((cl_layer_api_version *)param_value) = CL_LAYER_API_VERSION_100; - if (param_value_size_ret) - *param_value_size_ret = sizeof(cl_layer_api_version); + sz = sizeof(api_version); + src = &api_version; + break; + case CL_LAYER_NAME: + sz = sizeof(name); + src = name; break; default: return CL_INVALID_VALUE; } - return CL_SUCCESS; + return set_param_value(param_value_size, param_value, param_value_size_ret, sz, src); } CL_API_ENTRY cl_int CL_API_CALL @@ -53,7 +77,7 @@ clInitLayer( const struct _cl_icd_dispatch *target_dispatch, cl_uint *num_entries_out, const struct _cl_icd_dispatch **layer_dispatch_ret) { - if (!target_dispatch || !layer_dispatch_ret ||!num_entries_out || num_entries < sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs)) + if (!target_dispatch || !layer_dispatch_ret || !num_entries_out || num_entries < sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs)) return CL_INVALID_VALUE; _init_dispatch(); @@ -61,6 +85,7 @@ clInitLayer( tdispatch = target_dispatch; *layer_dispatch_ret = &dispatch; *num_entries_out = sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs); + return CL_SUCCESS; } diff --git a/deps/opencl-icd-loader/test/layer/icd_print_layer_generated.c b/deps/opencl-icd-loader/test/layer/icd_print_layer_generated.c index 76b77f9a4..ee9d19e5c 100644 --- a/deps/opencl-icd-loader/test/layer/icd_print_layer_generated.c +++ b/deps/opencl-icd-loader/test/layer/icd_print_layer_generated.c @@ -20,7 +20,7 @@ /////////////////////////////////////////////////////////////////////////////// // Core APIs: -static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformIDs_wrap( +static cl_int CL_API_CALL clGetPlatformIDs_wrap( cl_uint num_entries, cl_platform_id* platforms, cl_uint* num_platforms) CL_API_SUFFIX__VERSION_1_0 @@ -33,7 +33,7 @@ return tdispatch->clGetPlatformIDs( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetPlatformInfo_wrap( +static cl_int CL_API_CALL clGetPlatformInfo_wrap( cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, @@ -50,7 +50,7 @@ return tdispatch->clGetPlatformInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDs_wrap( +static cl_int CL_API_CALL clGetDeviceIDs_wrap( cl_platform_id platform, cl_device_type device_type, cl_uint num_entries, @@ -67,7 +67,7 @@ return tdispatch->clGetDeviceIDs( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo_wrap( +static cl_int CL_API_CALL clGetDeviceInfo_wrap( cl_device_id device, cl_device_info param_name, size_t param_value_size, @@ -84,7 +84,7 @@ return tdispatch->clGetDeviceInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_context CL_API_CALL clCreateContext_wrap( +static cl_context CL_API_CALL clCreateContext_wrap( const cl_context_properties* properties, cl_uint num_devices, const cl_device_id* devices, @@ -103,7 +103,7 @@ return tdispatch->clCreateContext( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType_wrap( +static cl_context CL_API_CALL clCreateContextFromType_wrap( const cl_context_properties* properties, cl_device_type device_type, void (CL_CALLBACK* pfn_notify)(const char* errinfo, const void* private_info, size_t cb, void* user_data), @@ -120,7 +120,7 @@ return tdispatch->clCreateContextFromType( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainContext_wrap( +static cl_int CL_API_CALL clRetainContext_wrap( cl_context context) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainContext\n"); @@ -129,7 +129,7 @@ return tdispatch->clRetainContext( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseContext_wrap( +static cl_int CL_API_CALL clReleaseContext_wrap( cl_context context) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseContext\n"); @@ -138,7 +138,7 @@ return tdispatch->clReleaseContext( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo_wrap( +static cl_int CL_API_CALL clGetContextInfo_wrap( cl_context context, cl_context_info param_name, size_t param_value_size, @@ -155,7 +155,7 @@ return tdispatch->clGetContextInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue_wrap( +static cl_int CL_API_CALL clRetainCommandQueue_wrap( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainCommandQueue\n"); @@ -164,7 +164,7 @@ return tdispatch->clRetainCommandQueue( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue_wrap( +static cl_int CL_API_CALL clReleaseCommandQueue_wrap( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseCommandQueue\n"); @@ -173,7 +173,7 @@ return tdispatch->clReleaseCommandQueue( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetCommandQueueInfo_wrap( +static cl_int CL_API_CALL clGetCommandQueueInfo_wrap( cl_command_queue command_queue, cl_command_queue_info param_name, size_t param_value_size, @@ -190,7 +190,7 @@ return tdispatch->clGetCommandQueueInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer_wrap( +static cl_mem CL_API_CALL clCreateBuffer_wrap( cl_context context, cl_mem_flags flags, size_t size, @@ -207,7 +207,7 @@ return tdispatch->clCreateBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject_wrap( +static cl_int CL_API_CALL clRetainMemObject_wrap( cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainMemObject\n"); @@ -216,7 +216,7 @@ return tdispatch->clRetainMemObject( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject_wrap( +static cl_int CL_API_CALL clReleaseMemObject_wrap( cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseMemObject\n"); @@ -225,7 +225,7 @@ return tdispatch->clReleaseMemObject( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetSupportedImageFormats_wrap( +static cl_int CL_API_CALL clGetSupportedImageFormats_wrap( cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, @@ -244,7 +244,7 @@ return tdispatch->clGetSupportedImageFormats( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo_wrap( +static cl_int CL_API_CALL clGetMemObjectInfo_wrap( cl_mem memobj, cl_mem_info param_name, size_t param_value_size, @@ -261,7 +261,7 @@ return tdispatch->clGetMemObjectInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo_wrap( +static cl_int CL_API_CALL clGetImageInfo_wrap( cl_mem image, cl_image_info param_name, size_t param_value_size, @@ -278,7 +278,7 @@ return tdispatch->clGetImageInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainSampler_wrap( +static cl_int CL_API_CALL clRetainSampler_wrap( cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainSampler\n"); @@ -287,7 +287,7 @@ return tdispatch->clRetainSampler( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler_wrap( +static cl_int CL_API_CALL clReleaseSampler_wrap( cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseSampler\n"); @@ -296,7 +296,7 @@ return tdispatch->clReleaseSampler( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo_wrap( +static cl_int CL_API_CALL clGetSamplerInfo_wrap( cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, @@ -313,7 +313,7 @@ return tdispatch->clGetSamplerInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource_wrap( +static cl_program CL_API_CALL clCreateProgramWithSource_wrap( cl_context context, cl_uint count, const char** strings, @@ -330,7 +330,7 @@ return tdispatch->clCreateProgramWithSource( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBinary_wrap( +static cl_program CL_API_CALL clCreateProgramWithBinary_wrap( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -351,7 +351,7 @@ return tdispatch->clCreateProgramWithBinary( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainProgram_wrap( +static cl_int CL_API_CALL clRetainProgram_wrap( cl_program program) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainProgram\n"); @@ -360,7 +360,7 @@ return tdispatch->clRetainProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram_wrap( +static cl_int CL_API_CALL clReleaseProgram_wrap( cl_program program) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseProgram\n"); @@ -369,7 +369,7 @@ return tdispatch->clReleaseProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clBuildProgram_wrap( +static cl_int CL_API_CALL clBuildProgram_wrap( cl_program program, cl_uint num_devices, const cl_device_id* device_list, @@ -388,7 +388,7 @@ return tdispatch->clBuildProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo_wrap( +static cl_int CL_API_CALL clGetProgramInfo_wrap( cl_program program, cl_program_info param_name, size_t param_value_size, @@ -405,7 +405,7 @@ return tdispatch->clGetProgramInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetProgramBuildInfo_wrap( +static cl_int CL_API_CALL clGetProgramBuildInfo_wrap( cl_program program, cl_device_id device, cl_program_build_info param_name, @@ -424,7 +424,7 @@ return tdispatch->clGetProgramBuildInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel_wrap( +static cl_kernel CL_API_CALL clCreateKernel_wrap( cl_program program, const char* kernel_name, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 @@ -437,7 +437,7 @@ return tdispatch->clCreateKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram_wrap( +static cl_int CL_API_CALL clCreateKernelsInProgram_wrap( cl_program program, cl_uint num_kernels, cl_kernel* kernels, @@ -452,7 +452,7 @@ return tdispatch->clCreateKernelsInProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainKernel_wrap( +static cl_int CL_API_CALL clRetainKernel_wrap( cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainKernel\n"); @@ -461,7 +461,7 @@ return tdispatch->clRetainKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel_wrap( +static cl_int CL_API_CALL clReleaseKernel_wrap( cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseKernel\n"); @@ -470,7 +470,7 @@ return tdispatch->clReleaseKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg_wrap( +static cl_int CL_API_CALL clSetKernelArg_wrap( cl_kernel kernel, cl_uint arg_index, size_t arg_size, @@ -485,7 +485,7 @@ return tdispatch->clSetKernelArg( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo_wrap( +static cl_int CL_API_CALL clGetKernelInfo_wrap( cl_kernel kernel, cl_kernel_info param_name, size_t param_value_size, @@ -502,7 +502,7 @@ return tdispatch->clGetKernelInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelWorkGroupInfo_wrap( +static cl_int CL_API_CALL clGetKernelWorkGroupInfo_wrap( cl_kernel kernel, cl_device_id device, cl_kernel_work_group_info param_name, @@ -521,7 +521,7 @@ return tdispatch->clGetKernelWorkGroupInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents_wrap( +static cl_int CL_API_CALL clWaitForEvents_wrap( cl_uint num_events, const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0 { @@ -532,7 +532,7 @@ return tdispatch->clWaitForEvents( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo_wrap( +static cl_int CL_API_CALL clGetEventInfo_wrap( cl_event event, cl_event_info param_name, size_t param_value_size, @@ -549,7 +549,7 @@ return tdispatch->clGetEventInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainEvent_wrap( +static cl_int CL_API_CALL clRetainEvent_wrap( cl_event event) CL_API_SUFFIX__VERSION_1_0 { printf("clRetainEvent\n"); @@ -558,7 +558,7 @@ return tdispatch->clRetainEvent( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent_wrap( +static cl_int CL_API_CALL clReleaseEvent_wrap( cl_event event) CL_API_SUFFIX__VERSION_1_0 { printf("clReleaseEvent\n"); @@ -567,7 +567,7 @@ return tdispatch->clReleaseEvent( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo_wrap( +static cl_int CL_API_CALL clGetEventProfilingInfo_wrap( cl_event event, cl_profiling_info param_name, size_t param_value_size, @@ -584,7 +584,7 @@ return tdispatch->clGetEventProfilingInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clFlush_wrap( +static cl_int CL_API_CALL clFlush_wrap( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 { printf("clFlush\n"); @@ -593,7 +593,7 @@ return tdispatch->clFlush( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clFinish_wrap( +static cl_int CL_API_CALL clFinish_wrap( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 { printf("clFinish\n"); @@ -602,7 +602,7 @@ return tdispatch->clFinish( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer_wrap( +static cl_int CL_API_CALL clEnqueueReadBuffer_wrap( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, @@ -627,7 +627,7 @@ return tdispatch->clEnqueueReadBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer_wrap( +static cl_int CL_API_CALL clEnqueueWriteBuffer_wrap( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, @@ -652,7 +652,7 @@ return tdispatch->clEnqueueWriteBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer_wrap( +static cl_int CL_API_CALL clEnqueueCopyBuffer_wrap( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, @@ -677,7 +677,7 @@ return tdispatch->clEnqueueCopyBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadImage_wrap( +static cl_int CL_API_CALL clEnqueueReadImage_wrap( cl_command_queue command_queue, cl_mem image, cl_bool blocking_read, @@ -706,7 +706,7 @@ return tdispatch->clEnqueueReadImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteImage_wrap( +static cl_int CL_API_CALL clEnqueueWriteImage_wrap( cl_command_queue command_queue, cl_mem image, cl_bool blocking_write, @@ -735,7 +735,7 @@ return tdispatch->clEnqueueWriteImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImage_wrap( +static cl_int CL_API_CALL clEnqueueCopyImage_wrap( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_image, @@ -760,7 +760,7 @@ return tdispatch->clEnqueueCopyImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyImageToBuffer_wrap( +static cl_int CL_API_CALL clEnqueueCopyImageToBuffer_wrap( cl_command_queue command_queue, cl_mem src_image, cl_mem dst_buffer, @@ -785,7 +785,7 @@ return tdispatch->clEnqueueCopyImageToBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferToImage_wrap( +static cl_int CL_API_CALL clEnqueueCopyBufferToImage_wrap( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_image, @@ -810,7 +810,7 @@ return tdispatch->clEnqueueCopyBufferToImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer_wrap( +static void* CL_API_CALL clEnqueueMapBuffer_wrap( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, @@ -837,7 +837,7 @@ return tdispatch->clEnqueueMapBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void* CL_API_CALL clEnqueueMapImage_wrap( +static void* CL_API_CALL clEnqueueMapImage_wrap( cl_command_queue command_queue, cl_mem image, cl_bool blocking_map, @@ -868,7 +868,7 @@ return tdispatch->clEnqueueMapImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueUnmapMemObject_wrap( +static cl_int CL_API_CALL clEnqueueUnmapMemObject_wrap( cl_command_queue command_queue, cl_mem memobj, void* mapped_ptr, @@ -887,7 +887,7 @@ return tdispatch->clEnqueueUnmapMemObject( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNDRangeKernel_wrap( +static cl_int CL_API_CALL clEnqueueNDRangeKernel_wrap( cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, @@ -912,7 +912,7 @@ return tdispatch->clEnqueueNDRangeKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueNativeKernel_wrap( +static cl_int CL_API_CALL clEnqueueNativeKernel_wrap( cl_command_queue command_queue, void (CL_CALLBACK* user_func)(void*), void* args, @@ -939,7 +939,7 @@ return tdispatch->clEnqueueNativeKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty_wrap( +static cl_int CL_API_CALL clSetCommandQueueProperty_wrap( cl_command_queue command_queue, cl_command_queue_properties properties, cl_bool enable, @@ -954,7 +954,7 @@ return tdispatch->clSetCommandQueueProperty( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage2D_wrap( +static cl_mem CL_API_CALL clCreateImage2D_wrap( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -977,7 +977,7 @@ return tdispatch->clCreateImage2D( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage3D_wrap( +static cl_mem CL_API_CALL clCreateImage3D_wrap( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -1004,7 +1004,7 @@ return tdispatch->clCreateImage3D( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker_wrap( +static cl_int CL_API_CALL clEnqueueMarker_wrap( cl_command_queue command_queue, cl_event* event) CL_API_SUFFIX__VERSION_1_1_DEPRECATED { @@ -1015,7 +1015,7 @@ return tdispatch->clEnqueueMarker( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents_wrap( +static cl_int CL_API_CALL clEnqueueWaitForEvents_wrap( cl_command_queue command_queue, cl_uint num_events, const cl_event* event_list) CL_API_SUFFIX__VERSION_1_1_DEPRECATED @@ -1028,7 +1028,7 @@ return tdispatch->clEnqueueWaitForEvents( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier_wrap( +static cl_int CL_API_CALL clEnqueueBarrier_wrap( cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_1_DEPRECATED { printf("clEnqueueBarrier\n"); @@ -1037,7 +1037,7 @@ return tdispatch->clEnqueueBarrier( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler_wrap( +static cl_int CL_API_CALL clUnloadCompiler_wrap( void ) CL_API_SUFFIX__VERSION_1_1_DEPRECATED { printf("clUnloadCompiler\n"); @@ -1046,7 +1046,7 @@ return tdispatch->clUnloadCompiler( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress_wrap( +static void* CL_API_CALL clGetExtensionFunctionAddress_wrap( const char* func_name) CL_API_SUFFIX__VERSION_1_1_DEPRECATED { printf("clGetExtensionFunctionAddress\n"); @@ -1055,7 +1055,7 @@ return tdispatch->clGetExtensionFunctionAddress( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue_wrap( +static cl_command_queue CL_API_CALL clCreateCommandQueue_wrap( cl_context context, cl_device_id device, cl_command_queue_properties properties, @@ -1070,7 +1070,7 @@ return tdispatch->clCreateCommandQueue( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler_wrap( +static cl_sampler CL_API_CALL clCreateSampler_wrap( cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, @@ -1087,7 +1087,7 @@ return tdispatch->clCreateSampler( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueTask_wrap( +static cl_int CL_API_CALL clEnqueueTask_wrap( cl_command_queue command_queue, cl_kernel kernel, cl_uint num_events_in_wait_list, @@ -1104,7 +1104,7 @@ return tdispatch->clEnqueueTask( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer_wrap( +static cl_mem CL_API_CALL clCreateSubBuffer_wrap( cl_mem buffer, cl_mem_flags flags, cl_buffer_create_type buffer_create_type, @@ -1121,7 +1121,7 @@ return tdispatch->clCreateSubBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback_wrap( +static cl_int CL_API_CALL clSetMemObjectDestructorCallback_wrap( cl_mem memobj, void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_1_1 @@ -1134,7 +1134,7 @@ return tdispatch->clSetMemObjectDestructorCallback( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent_wrap( +static cl_event CL_API_CALL clCreateUserEvent_wrap( cl_context context, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 { @@ -1145,7 +1145,7 @@ return tdispatch->clCreateUserEvent( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus_wrap( +static cl_int CL_API_CALL clSetUserEventStatus_wrap( cl_event event, cl_int execution_status) CL_API_SUFFIX__VERSION_1_1 { @@ -1156,7 +1156,7 @@ return tdispatch->clSetUserEventStatus( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback_wrap( +static cl_int CL_API_CALL clSetEventCallback_wrap( cl_event event, cl_int command_exec_callback_type, void (CL_CALLBACK* pfn_notify)(cl_event event, cl_int event_command_status, void *user_data), @@ -1171,7 +1171,7 @@ return tdispatch->clSetEventCallback( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBufferRect_wrap( +static cl_int CL_API_CALL clEnqueueReadBufferRect_wrap( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, @@ -1206,7 +1206,7 @@ return tdispatch->clEnqueueReadBufferRect( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect_wrap( +static cl_int CL_API_CALL clEnqueueWriteBufferRect_wrap( cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, @@ -1241,7 +1241,7 @@ return tdispatch->clEnqueueWriteBufferRect( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBufferRect_wrap( +static cl_int CL_API_CALL clEnqueueCopyBufferRect_wrap( cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, @@ -1274,7 +1274,7 @@ return tdispatch->clEnqueueCopyBufferRect( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices_wrap( +static cl_int CL_API_CALL clCreateSubDevices_wrap( cl_device_id in_device, const cl_device_partition_property* properties, cl_uint num_devices, @@ -1291,7 +1291,7 @@ return tdispatch->clCreateSubDevices( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clRetainDevice_wrap( +static cl_int CL_API_CALL clRetainDevice_wrap( cl_device_id device) CL_API_SUFFIX__VERSION_1_2 { printf("clRetainDevice\n"); @@ -1300,7 +1300,7 @@ return tdispatch->clRetainDevice( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice_wrap( +static cl_int CL_API_CALL clReleaseDevice_wrap( cl_device_id device) CL_API_SUFFIX__VERSION_1_2 { printf("clReleaseDevice\n"); @@ -1309,7 +1309,7 @@ return tdispatch->clReleaseDevice( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImage_wrap( +static cl_mem CL_API_CALL clCreateImage_wrap( cl_context context, cl_mem_flags flags, const cl_image_format* image_format, @@ -1328,7 +1328,7 @@ return tdispatch->clCreateImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_wrap( +static cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_wrap( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -1345,7 +1345,7 @@ return tdispatch->clCreateProgramWithBuiltInKernels( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clCompileProgram_wrap( +static cl_int CL_API_CALL clCompileProgram_wrap( cl_program program, cl_uint num_devices, const cl_device_id* device_list, @@ -1370,7 +1370,7 @@ return tdispatch->clCompileProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_program CL_API_CALL clLinkProgram_wrap( +static cl_program CL_API_CALL clLinkProgram_wrap( cl_context context, cl_uint num_devices, const cl_device_id* device_list, @@ -1395,7 +1395,7 @@ return tdispatch->clLinkProgram( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler_wrap( +static cl_int CL_API_CALL clUnloadPlatformCompiler_wrap( cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 { printf("clUnloadPlatformCompiler\n"); @@ -1404,7 +1404,7 @@ return tdispatch->clUnloadPlatformCompiler( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo_wrap( +static cl_int CL_API_CALL clGetKernelArgInfo_wrap( cl_kernel kernel, cl_uint arg_index, cl_kernel_arg_info param_name, @@ -1423,7 +1423,7 @@ return tdispatch->clGetKernelArgInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer_wrap( +static cl_int CL_API_CALL clEnqueueFillBuffer_wrap( cl_command_queue command_queue, cl_mem buffer, const void* pattern, @@ -1448,7 +1448,7 @@ return tdispatch->clEnqueueFillBuffer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage_wrap( +static cl_int CL_API_CALL clEnqueueFillImage_wrap( cl_command_queue command_queue, cl_mem image, const void* fill_color, @@ -1471,7 +1471,7 @@ return tdispatch->clEnqueueFillImage( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMigrateMemObjects_wrap( +static cl_int CL_API_CALL clEnqueueMigrateMemObjects_wrap( cl_command_queue command_queue, cl_uint num_mem_objects, const cl_mem* mem_objects, @@ -1492,7 +1492,7 @@ return tdispatch->clEnqueueMigrateMemObjects( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList_wrap( +static cl_int CL_API_CALL clEnqueueMarkerWithWaitList_wrap( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, @@ -1507,7 +1507,7 @@ return tdispatch->clEnqueueMarkerWithWaitList( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList_wrap( +static cl_int CL_API_CALL clEnqueueBarrierWithWaitList_wrap( cl_command_queue command_queue, cl_uint num_events_in_wait_list, const cl_event* event_wait_list, @@ -1522,7 +1522,7 @@ return tdispatch->clEnqueueBarrierWithWaitList( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_wrap( +static void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_wrap( cl_platform_id platform, const char* func_name) CL_API_SUFFIX__VERSION_1_2 { @@ -1533,7 +1533,7 @@ return tdispatch->clGetExtensionFunctionAddressForPlatform( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_wrap( +static cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_wrap( cl_context context, cl_device_id device, const cl_queue_properties* properties, @@ -1548,7 +1548,7 @@ return tdispatch->clCreateCommandQueueWithProperties( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreatePipe_wrap( +static cl_mem CL_API_CALL clCreatePipe_wrap( cl_context context, cl_mem_flags flags, cl_uint pipe_packet_size, @@ -1567,7 +1567,7 @@ return tdispatch->clCreatePipe( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo_wrap( +static cl_int CL_API_CALL clGetPipeInfo_wrap( cl_mem pipe, cl_pipe_info param_name, size_t param_value_size, @@ -1584,7 +1584,7 @@ return tdispatch->clGetPipeInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void* CL_API_CALL clSVMAlloc_wrap( +static void* CL_API_CALL clSVMAlloc_wrap( cl_context context, cl_svm_mem_flags flags, size_t size, @@ -1599,7 +1599,7 @@ return tdispatch->clSVMAlloc( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY void CL_API_CALL clSVMFree_wrap( +static void CL_API_CALL clSVMFree_wrap( cl_context context, void* svm_pointer) CL_API_SUFFIX__VERSION_2_0 { @@ -1610,7 +1610,7 @@ tdispatch->clSVMFree( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties_wrap( +static cl_sampler CL_API_CALL clCreateSamplerWithProperties_wrap( cl_context context, const cl_sampler_properties* sampler_properties, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0 @@ -1623,7 +1623,7 @@ return tdispatch->clCreateSamplerWithProperties( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer_wrap( +static cl_int CL_API_CALL clSetKernelArgSVMPointer_wrap( cl_kernel kernel, cl_uint arg_index, const void* arg_value) CL_API_SUFFIX__VERSION_2_0 @@ -1636,7 +1636,7 @@ return tdispatch->clSetKernelArgSVMPointer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo_wrap( +static cl_int CL_API_CALL clSetKernelExecInfo_wrap( cl_kernel kernel, cl_kernel_exec_info param_name, size_t param_value_size, @@ -1651,7 +1651,7 @@ return tdispatch->clSetKernelExecInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMFree_wrap( +static cl_int CL_API_CALL clEnqueueSVMFree_wrap( cl_command_queue command_queue, cl_uint num_svm_pointers, void* svm_pointers[], @@ -1674,7 +1674,7 @@ return tdispatch->clEnqueueSVMFree( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemcpy_wrap( +static cl_int CL_API_CALL clEnqueueSVMMemcpy_wrap( cl_command_queue command_queue, cl_bool blocking_copy, void* dst_ptr, @@ -1697,7 +1697,7 @@ return tdispatch->clEnqueueSVMMemcpy( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMemFill_wrap( +static cl_int CL_API_CALL clEnqueueSVMMemFill_wrap( cl_command_queue command_queue, void* svm_ptr, const void* pattern, @@ -1720,7 +1720,7 @@ return tdispatch->clEnqueueSVMMemFill( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap_wrap( +static cl_int CL_API_CALL clEnqueueSVMMap_wrap( cl_command_queue command_queue, cl_bool blocking_map, cl_map_flags flags, @@ -1743,7 +1743,7 @@ return tdispatch->clEnqueueSVMMap( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMUnmap_wrap( +static cl_int CL_API_CALL clEnqueueSVMUnmap_wrap( cl_command_queue command_queue, void* svm_ptr, cl_uint num_events_in_wait_list, @@ -1760,7 +1760,7 @@ return tdispatch->clEnqueueSVMUnmap( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_wrap( +static cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_wrap( cl_context context, cl_device_id device, cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1 @@ -1773,7 +1773,7 @@ return tdispatch->clSetDefaultDeviceCommandQueue( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer_wrap( +static cl_int CL_API_CALL clGetDeviceAndHostTimer_wrap( cl_device_id device, cl_ulong* device_timestamp, cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1 @@ -1786,7 +1786,7 @@ return tdispatch->clGetDeviceAndHostTimer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer_wrap( +static cl_int CL_API_CALL clGetHostTimer_wrap( cl_device_id device, cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1 { @@ -1797,7 +1797,7 @@ return tdispatch->clGetHostTimer( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL_wrap( +static cl_program CL_API_CALL clCreateProgramWithIL_wrap( cl_context context, const void* il, size_t length, @@ -1812,7 +1812,7 @@ return tdispatch->clCreateProgramWithIL( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel_wrap( +static cl_kernel CL_API_CALL clCloneKernel_wrap( cl_kernel source_kernel, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1 { @@ -1823,7 +1823,7 @@ return tdispatch->clCloneKernel( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfo_wrap( +static cl_int CL_API_CALL clGetKernelSubGroupInfo_wrap( cl_kernel kernel, cl_device_id device, cl_kernel_sub_group_info param_name, @@ -1846,7 +1846,7 @@ return tdispatch->clGetKernelSubGroupInfo( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMigrateMem_wrap( +static cl_int CL_API_CALL clEnqueueSVMMigrateMem_wrap( cl_command_queue command_queue, cl_uint num_svm_pointers, const void** svm_pointers, @@ -1869,7 +1869,7 @@ return tdispatch->clEnqueueSVMMigrateMem( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant_wrap( +static cl_int CL_API_CALL clSetProgramSpecializationConstant_wrap( cl_program program, cl_uint spec_id, size_t spec_size, @@ -1884,7 +1884,7 @@ return tdispatch->clSetProgramSpecializationConstant( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback_wrap( +static cl_int CL_API_CALL clSetProgramReleaseCallback_wrap( cl_program program, void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_2_2_DEPRECATED @@ -1897,7 +1897,7 @@ return tdispatch->clSetProgramReleaseCallback( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback_wrap( +static cl_int CL_API_CALL clSetContextDestructorCallback_wrap( cl_context context, void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), void* user_data) CL_API_SUFFIX__VERSION_3_0 @@ -1910,7 +1910,7 @@ return tdispatch->clSetContextDestructorCallback( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties_wrap( +static cl_mem CL_API_CALL clCreateBufferWithProperties_wrap( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, @@ -1929,7 +1929,7 @@ return tdispatch->clCreateBufferWithProperties( } /////////////////////////////////////////////////////////////////////////////// -static CL_API_ENTRY cl_mem CL_API_CALL clCreateImageWithProperties_wrap( +static cl_mem CL_API_CALL clCreateImageWithProperties_wrap( cl_context context, const cl_mem_properties* properties, cl_mem_flags flags, @@ -1952,21 +1952,21 @@ return tdispatch->clCreateImageWithProperties( /////////////////////////////////////////////////////////////////////////////// // cl_ext_device_fission -static CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT_wrap( +static cl_int CL_API_CALL clReleaseDeviceEXT_wrap( cl_device_id device) CL_API_SUFFIX__VERSION_1_1 { printf("clReleaseDeviceEXT\n"); return tdispatch->clReleaseDeviceEXT( device); } -static CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT_wrap( +static cl_int CL_API_CALL clRetainDeviceEXT_wrap( cl_device_id device) CL_API_SUFFIX__VERSION_1_1 { printf("clRetainDeviceEXT\n"); return tdispatch->clRetainDeviceEXT( device); } -static CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevicesEXT_wrap( +static cl_int CL_API_CALL clCreateSubDevicesEXT_wrap( cl_device_id in_device, const cl_device_partition_property_ext* properties, cl_uint num_entries, @@ -1987,7 +1987,7 @@ return tdispatch->clCreateSubDevicesEXT( // cl_khr_d3d10_sharing #if defined(_WIN32) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_wrap( +static cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_wrap( cl_platform_id platform, cl_d3d10_device_source_khr d3d_device_source, void* d3d_object, @@ -2006,7 +2006,7 @@ return tdispatch->clGetDeviceIDsFromD3D10KHR( devices, num_devices); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_wrap( cl_context context, cl_mem_flags flags, ID3D10Buffer* resource, @@ -2019,7 +2019,7 @@ return tdispatch->clCreateFromD3D10BufferKHR( resource, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_wrap( cl_context context, cl_mem_flags flags, ID3D10Texture2D* resource, @@ -2034,7 +2034,7 @@ return tdispatch->clCreateFromD3D10Texture2DKHR( subresource, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_wrap( cl_context context, cl_mem_flags flags, ID3D10Texture3D* resource, @@ -2049,7 +2049,7 @@ return tdispatch->clCreateFromD3D10Texture3DKHR( subresource, errcode_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2066,7 +2066,7 @@ return tdispatch->clEnqueueAcquireD3D10ObjectsKHR( event_wait_list, event); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2091,7 +2091,7 @@ return tdispatch->clEnqueueReleaseD3D10ObjectsKHR( // cl_khr_d3d11_sharing #if defined(_WIN32) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_wrap( +static cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_wrap( cl_platform_id platform, cl_d3d11_device_source_khr d3d_device_source, void* d3d_object, @@ -2110,7 +2110,7 @@ return tdispatch->clGetDeviceIDsFromD3D11KHR( devices, num_devices); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_wrap( cl_context context, cl_mem_flags flags, ID3D11Buffer* resource, @@ -2123,7 +2123,7 @@ return tdispatch->clCreateFromD3D11BufferKHR( resource, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_wrap( cl_context context, cl_mem_flags flags, ID3D11Texture2D* resource, @@ -2138,7 +2138,7 @@ return tdispatch->clCreateFromD3D11Texture2DKHR( subresource, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_wrap( +static cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_wrap( cl_context context, cl_mem_flags flags, ID3D11Texture3D* resource, @@ -2153,7 +2153,7 @@ return tdispatch->clCreateFromD3D11Texture3DKHR( subresource, errcode_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2170,7 +2170,7 @@ return tdispatch->clEnqueueAcquireD3D11ObjectsKHR( event_wait_list, event); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2195,7 +2195,7 @@ return tdispatch->clEnqueueReleaseD3D11ObjectsKHR( // cl_khr_dx9_media_sharing #if defined(_WIN32) -static CL_API_ENTRY cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_wrap( +static cl_int CL_API_CALL clGetDeviceIDsFromDX9MediaAdapterKHR_wrap( cl_platform_id platform, cl_uint num_media_adapters, cl_dx9_media_adapter_type_khr* media_adapter_type, @@ -2216,7 +2216,7 @@ return tdispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( devices, num_devices); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_wrap( +static cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_wrap( cl_context context, cl_mem_flags flags, cl_dx9_media_adapter_type_khr adapter_type, @@ -2233,7 +2233,7 @@ return tdispatch->clCreateFromDX9MediaSurfaceKHR( plane, errcode_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_wrap( +static cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2250,7 +2250,7 @@ return tdispatch->clEnqueueAcquireDX9MediaSurfacesKHR( event_wait_list, event); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_wrap( +static cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2273,7 +2273,7 @@ return tdispatch->clEnqueueReleaseDX9MediaSurfacesKHR( /////////////////////////////////////////////////////////////////////////////// // cl_khr_egl_event -static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_wrap( +static cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_wrap( cl_context context, CLeglSyncKHR sync, CLeglDisplayKHR display, @@ -2290,7 +2290,7 @@ return tdispatch->clCreateEventFromEGLSyncKHR( /////////////////////////////////////////////////////////////////////////////// // cl_khr_egl_image -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromEGLImageKHR_wrap( +static cl_mem CL_API_CALL clCreateFromEGLImageKHR_wrap( cl_context context, CLeglDisplayKHR egldisplay, CLeglImageKHR eglimage, @@ -2307,7 +2307,7 @@ return tdispatch->clCreateFromEGLImageKHR( properties, errcode_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2324,7 +2324,7 @@ return tdispatch->clEnqueueAcquireEGLObjectsKHR( event_wait_list, event); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_wrap( +static cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2345,7 +2345,7 @@ return tdispatch->clEnqueueReleaseEGLObjectsKHR( /////////////////////////////////////////////////////////////////////////////// // cl_khr_gl_event -static CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR_wrap( +static cl_event CL_API_CALL clCreateEventFromGLsyncKHR_wrap( cl_context context, cl_GLsync sync, cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 @@ -2360,7 +2360,7 @@ return tdispatch->clCreateEventFromGLsyncKHR( /////////////////////////////////////////////////////////////////////////////// // cl_khr_gl_sharing -static CL_API_ENTRY cl_int CL_API_CALL clGetGLContextInfoKHR_wrap( +static cl_int CL_API_CALL clGetGLContextInfoKHR_wrap( const cl_context_properties* properties, cl_gl_context_info param_name, size_t param_value_size, @@ -2375,11 +2375,11 @@ return tdispatch->clGetGLContextInfoKHR( param_value, param_value_size_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer_wrap( +static cl_mem CL_API_CALL clCreateFromGLBuffer_wrap( cl_context context, cl_mem_flags flags, cl_GLuint bufobj, - int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 { printf("clCreateFromGLBuffer\n"); return tdispatch->clCreateFromGLBuffer( @@ -2388,7 +2388,7 @@ return tdispatch->clCreateFromGLBuffer( bufobj, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture_wrap( +static cl_mem CL_API_CALL clCreateFromGLTexture_wrap( cl_context context, cl_mem_flags flags, cl_GLenum target, @@ -2405,41 +2405,7 @@ return tdispatch->clCreateFromGLTexture( texture, errcode_ret); } -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture2D_wrap( - cl_context context, - cl_mem_flags flags, - cl_GLenum target, - cl_GLint miplevel, - cl_GLuint texture, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED -{ -printf("clCreateFromGLTexture2D\n"); -return tdispatch->clCreateFromGLTexture2D( - context, - flags, - target, - miplevel, - texture, - errcode_ret); -} -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLTexture3D_wrap( - cl_context context, - cl_mem_flags flags, - cl_GLenum target, - cl_GLint miplevel, - cl_GLuint texture, - cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED -{ -printf("clCreateFromGLTexture3D\n"); -return tdispatch->clCreateFromGLTexture3D( - context, - flags, - target, - miplevel, - texture, - errcode_ret); -} -static CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer_wrap( +static cl_mem CL_API_CALL clCreateFromGLRenderbuffer_wrap( cl_context context, cl_mem_flags flags, cl_GLuint renderbuffer, @@ -2452,7 +2418,7 @@ return tdispatch->clCreateFromGLRenderbuffer( renderbuffer, errcode_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo_wrap( +static cl_int CL_API_CALL clGetGLObjectInfo_wrap( cl_mem memobj, cl_gl_object_type* gl_object_type, cl_GLuint* gl_object_name) CL_API_SUFFIX__VERSION_1_0 @@ -2463,7 +2429,7 @@ return tdispatch->clGetGLObjectInfo( gl_object_type, gl_object_name); } -static CL_API_ENTRY cl_int CL_API_CALL clGetGLTextureInfo_wrap( +static cl_int CL_API_CALL clGetGLTextureInfo_wrap( cl_mem memobj, cl_gl_texture_info param_name, size_t param_value_size, @@ -2478,7 +2444,7 @@ return tdispatch->clGetGLTextureInfo( param_value, param_value_size_ret); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueAcquireGLObjects_wrap( +static cl_int CL_API_CALL clEnqueueAcquireGLObjects_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2495,7 +2461,7 @@ return tdispatch->clEnqueueAcquireGLObjects( event_wait_list, event); } -static CL_API_ENTRY cl_int CL_API_CALL clEnqueueReleaseGLObjects_wrap( +static cl_int CL_API_CALL clEnqueueReleaseGLObjects_wrap( cl_command_queue command_queue, cl_uint num_objects, const cl_mem* mem_objects, @@ -2512,11 +2478,45 @@ return tdispatch->clEnqueueReleaseGLObjects( event_wait_list, event); } +static cl_mem CL_API_CALL clCreateFromGLTexture2D_wrap( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clCreateFromGLTexture2D\n"); +return tdispatch->clCreateFromGLTexture2D( + context, + flags, + target, + miplevel, + texture, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromGLTexture3D_wrap( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clCreateFromGLTexture3D\n"); +return tdispatch->clCreateFromGLTexture3D( + context, + flags, + target, + miplevel, + texture, + errcode_ret); +} /////////////////////////////////////////////////////////////////////////////// // cl_khr_subgroups -static CL_API_ENTRY cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_wrap( +static cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_wrap( cl_kernel in_kernel, cl_device_id in_device, cl_kernel_sub_group_info param_name, diff --git a/deps/opencl-icd-loader/test/loader_test/icd_test_match.c b/deps/opencl-icd-loader/test/loader_test/icd_test_match.c index b70e741f7..cf791814b 100644 --- a/deps/opencl-icd-loader/test/loader_test/icd_test_match.c +++ b/deps/opencl-icd-loader/test/loader_test/icd_test_match.c @@ -6,7 +6,7 @@ #endif #include -int test_icd_match() +int test_icd_match(void) { int error = 0; char *app_log = NULL, *stub_log = NULL; diff --git a/deps/opencl-icd-loader/test/loader_test/main.c b/deps/opencl-icd-loader/test/loader_test/main.c index b8b730401..e10bee523 100644 --- a/deps/opencl-icd-loader/test/loader_test/main.c +++ b/deps/opencl-icd-loader/test/loader_test/main.c @@ -3,18 +3,17 @@ #include #include "param_struct.h" -extern int test_create_calls(); -extern int test_platforms(); -extern int test_cl_runtime(); -extern int test_kernel(); -extern int test_buffer_object(); -extern int test_program_objects(); -extern int test_image_objects(); -extern int test_sampler_objects(); -extern int test_OpenGL_share(); -extern int test_release_calls(); - -extern int test_icd_match(); +extern int test_create_calls(void); +extern int test_platforms(void); +extern int test_cl_runtime(void); +extern int test_kernel(void); +extern int test_buffer_object(void); +extern int test_program_objects(void); +extern int test_image_objects(void); +extern int test_sampler_objects(void); +extern int test_OpenGL_share(void); +extern int test_release_calls(void); +extern int test_icd_match(void); int main(int argc, char **argv) { diff --git a/deps/opencl-icd-loader/test/loader_test/test_buffer_object.c b/deps/opencl-icd-loader/test/loader_test/test_buffer_object.c index 38d5b9025..d133875af 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_buffer_object.c +++ b/deps/opencl-icd-loader/test/loader_test/test_buffer_object.c @@ -408,7 +408,7 @@ int test_clGetMemObjectInfo (const struct clGetMemObjectInfo_st *data) return 0; } -int test_buffer_object() +int test_buffer_object(void) { int i; for (i=0; ibuffer_create_info, data->errcode_ret); - clReleaseMemObjectData->memobj = buffer; + clReleaseMemObjectDataSubBuffer->memobj = subBuffer; test_icd_app_log("Value returned: %p\n", subBuffer); @@ -762,7 +770,7 @@ int test_clReleaseDevice(const struct clReleaseDevice_st* data) } -int test_create_calls() +int test_create_calls(void) { test_clGetPlatformIDs(clGetPlatformIDsData); @@ -780,12 +788,16 @@ int test_create_calls() test_clCreateBuffer(clCreateBufferData); + test_clReleaseMemObject(clReleaseMemObjectData); + test_clCreateBufferWithProperties(clCreateBufferWithPropertiesData); test_clCreateSubBuffer(clCreateSubBufferData); test_clCreateImage(clCreateImageData); + test_clReleaseMemObject(clReleaseMemObjectDataImage); + test_clCreateImageWithProperties(clCreateImageWithPropertiesData); test_clReleaseMemObject(clReleaseMemObjectDataImage); @@ -818,12 +830,14 @@ int test_create_calls() } -int test_release_calls() +int test_release_calls(void) { test_clReleaseSampler(clReleaseSamplerData); test_clReleaseMemObject(clReleaseMemObjectData); + test_clReleaseMemObject(clReleaseMemObjectDataSubBuffer); + test_clReleaseMemObject(clReleaseMemObjectDataImage); test_clReleaseEvent(clReleaseEventData); diff --git a/deps/opencl-icd-loader/test/loader_test/test_image_objects.c b/deps/opencl-icd-loader/test/loader_test/test_image_objects.c index c6b99e7d2..f214a30d7 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_image_objects.c +++ b/deps/opencl-icd-loader/test/loader_test/test_image_objects.c @@ -333,7 +333,7 @@ int test_clGetImageInfo(const struct clGetImageInfo_st *data) } -int test_image_objects() +int test_image_objects(void) { int i; diff --git a/deps/opencl-icd-loader/test/loader_test/test_kernel.c b/deps/opencl-icd-loader/test/loader_test/test_kernel.c index 2382eabb4..e76c77ff3 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_kernel.c +++ b/deps/opencl-icd-loader/test/loader_test/test_kernel.c @@ -514,7 +514,7 @@ int test_clFinish(const struct clFinish_st* data) return 0; } -int test_kernel() +int test_kernel(void) { int i; diff --git a/deps/opencl-icd-loader/test/loader_test/test_platforms.c b/deps/opencl-icd-loader/test/loader_test/test_platforms.c index 570073810..ca8362836 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_platforms.c +++ b/deps/opencl-icd-loader/test/loader_test/test_platforms.c @@ -189,7 +189,7 @@ int test_clRetainDevice(const struct clRetainDevice_st* data) return 0; } -int test_platforms() +int test_platforms(void) { int i; diff --git a/deps/opencl-icd-loader/test/loader_test/test_program_objects.c b/deps/opencl-icd-loader/test/loader_test/test_program_objects.c index 8e6437242..ec59da161 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_program_objects.c +++ b/deps/opencl-icd-loader/test/loader_test/test_program_objects.c @@ -123,7 +123,8 @@ int test_clCompileProgram(const struct clCompileProgram_st *data) int test_clLinkProgram(const struct clLinkProgram_st *data) { - cl_program program; + cl_program linked_program; + cl_int ret_val; test_icd_app_log("clLinkProgram(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", context, data->num_devices, @@ -135,7 +136,7 @@ int test_clLinkProgram(const struct clLinkProgram_st *data) data->user_data, data->errcode_ret); - program=clLinkProgram(context, + linked_program=clLinkProgram(context, data->num_devices, data->device_list, data->options, @@ -145,7 +146,11 @@ int test_clLinkProgram(const struct clLinkProgram_st *data) data->user_data, data->errcode_ret); - test_icd_app_log("Value returned: %p\n", program); + test_icd_app_log("Value returned: %p\n", linked_program); + + test_icd_app_log("clReleaseProgram(%p)\n", linked_program); + ret_val = clReleaseProgram(linked_program); + test_icd_app_log("Value returned: %d\n", ret_val); return 0; @@ -230,7 +235,7 @@ int test_clGetProgramBuildInfo(const struct clGetProgramBuildInfo_st *data) } -int test_program_objects() +int test_program_objects(void) { int i; diff --git a/deps/opencl-icd-loader/test/loader_test/test_sampler_objects.c b/deps/opencl-icd-loader/test/loader_test/test_sampler_objects.c index afc11be83..a7fbcb760 100644 --- a/deps/opencl-icd-loader/test/loader_test/test_sampler_objects.c +++ b/deps/opencl-icd-loader/test/loader_test/test_sampler_objects.c @@ -51,7 +51,7 @@ int test_clGetSamplerInfo(const struct clGetSamplerInfo_st *data) return 0; } -int test_sampler_objects() +int test_sampler_objects(void) { int i; diff --git a/deps/opencl-icd-loader/test/pkgconfig/bare/CMakeLists.txt b/deps/opencl-icd-loader/test/pkgconfig/bare/CMakeLists.txt index 5e4c099ed..f58f21e9e 100644 --- a/deps/opencl-icd-loader/test/pkgconfig/bare/CMakeLists.txt +++ b/deps/opencl-icd-loader/test/pkgconfig/bare/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES C @@ -35,7 +35,12 @@ add_test( COMMAND ${PROJECT_NAME} ) -set_tests_properties(${PROJECT_NAME} - PROPERTIES - ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" -) +if(DEFINED DRIVER_STUB_PATH) + file(TO_CMAKE_PATH "${DRIVER_STUB_PATH}" DRIVER_STUB_PATH_CMAKE) + string(REGEX MATCH ".*/" DRIVER_STUB_DIR "${DRIVER_STUB_PATH_CMAKE}") + set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" + WORKING_DIRECTORY "${DRIVER_STUB_DIR}" + ) +endif() diff --git a/deps/opencl-icd-loader/test/pkgconfig/pkgconfig.c b/deps/opencl-icd-loader/test/pkgconfig/pkgconfig.c index 7228099ad..aadd25f14 100644 --- a/deps/opencl-icd-loader/test/pkgconfig/pkgconfig.c +++ b/deps/opencl-icd-loader/test/pkgconfig/pkgconfig.c @@ -7,6 +7,7 @@ #include // printf #include // malloc #include // UINTMAX_MAX +#include // strcmp void checkErr(cl_int err, const char * name) { @@ -17,10 +18,11 @@ void checkErr(cl_int err, const char * name) } } -int main() +int main(void) { cl_int CL_err = CL_SUCCESS; cl_uint numPlatforms = 0; + cl_int stub_platform_found = CL_FALSE; CL_err = clGetPlatformIDs(0, NULL, &numPlatforms); checkErr(CL_err, "clGetPlatformIDs(numPlatforms)"); @@ -48,9 +50,21 @@ int main() checkErr(CL_err, "clGetPlatformInfo(CL_PLATFORM_VENDOR, vendor_length, platform_name)"); printf("%s\n", platform_name); + + if (strcmp(platform_name, "stubvendorxxx") == 0) + { + stub_platform_found = CL_TRUE; + } + fflush(NULL); free(platform_name); } + if (!stub_platform_found) + { + printf("Did not locate stub platform\n"); + return -1; + } + return 0; } diff --git a/deps/opencl-icd-loader/test/pkgconfig/pkgconfig/CMakeLists.txt b/deps/opencl-icd-loader/test/pkgconfig/pkgconfig/CMakeLists.txt new file mode 100644 index 000000000..436fffdb4 --- /dev/null +++ b/deps/opencl-icd-loader/test/pkgconfig/pkgconfig/CMakeLists.txt @@ -0,0 +1,60 @@ +cmake_minimum_required(VERSION 3.16) +find_package(PkgConfig REQUIRED) + +project(PkgConfigTest + LANGUAGES C +) + +pkg_check_modules(OPENCL REQUIRED OpenCL) + +if(CMAKE_VERSION VERSION_LESS 3.12) + link_directories("${OPENCL_LIBRARY_DIRS}") +endif() + +add_executable(${PROJECT_NAME} + ../pkgconfig.c +) + +target_include_directories(${PROJECT_NAME} + PRIVATE + ${OPENCL_INCLUDE_DIRS} +) + +if(CMAKE_VERSION VERSION_LESS 3.12) +target_link_libraries(${PROJECT_NAME} + PRIVATE + ${OPENCL_LIBRARIES} +) +else() +target_link_libraries(${PROJECT_NAME} + PRIVATE + ${OPENCL_LINK_LIBRARIES} +) +endif() + +target_compile_options(${PROJECT_NAME} + PRIVATE + ${OPENCL_CFLAGS_OTHER} +) + +target_compile_definitions(${PROJECT_NAME} + PRIVATE + CL_TARGET_OPENCL_VERSION=120 +) + +include(CTest) + +add_test( + NAME ${PROJECT_NAME} + COMMAND ${PROJECT_NAME} +) + +if(DEFINED DRIVER_STUB_PATH) + file(TO_CMAKE_PATH "${DRIVER_STUB_PATH}" DRIVER_STUB_PATH_CMAKE) + string(REGEX MATCH ".*/" DRIVER_STUB_DIR "${DRIVER_STUB_PATH_CMAKE}") + set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" + WORKING_DIRECTORY "${DRIVER_STUB_DIR}" + ) +endif() diff --git a/deps/opencl-icd-loader/test/pkgconfig/sdk/CMakeLists.txt b/deps/opencl-icd-loader/test/pkgconfig/sdk/CMakeLists.txt index fced859b7..83a52b70b 100644 --- a/deps/opencl-icd-loader/test/pkgconfig/sdk/CMakeLists.txt +++ b/deps/opencl-icd-loader/test/pkgconfig/sdk/CMakeLists.txt @@ -1,4 +1,4 @@ -cmake_minimum_required(VERSION 3.0) +cmake_minimum_required(VERSION 3.16) project(PkgConfigTest LANGUAGES C @@ -34,7 +34,12 @@ add_test( COMMAND ${PROJECT_NAME} ) -set_tests_properties(${PROJECT_NAME} - PROPERTIES - ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" -) +if(DEFINED DRIVER_STUB_PATH) + file(TO_CMAKE_PATH "${DRIVER_STUB_PATH}" DRIVER_STUB_PATH_CMAKE) + string(REGEX MATCH ".*/" DRIVER_STUB_DIR "${DRIVER_STUB_PATH_CMAKE}") + set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" + WORKING_DIRECTORY "${DRIVER_STUB_DIR}" + ) +endif() From f5777dd3112c877373f4d97cc0b29bfac721ae22 Mon Sep 17 00:00:00 2001 From: Vladimir Kutuev Date: Mon, 19 May 2025 18:04:09 +0300 Subject: [PATCH 4/8] gh-233: update cxxopts dependency --- deps/cxxopts/.github/workflows/cmake.yml | 79 +- deps/cxxopts/.gitignore | 78 +- deps/cxxopts/BUILD.bazel | 8 + deps/cxxopts/CHANGELOG.md | 46 +- deps/cxxopts/CMakeLists.txt | 7 +- deps/cxxopts/INSTALL | 23 + deps/cxxopts/README.md | 49 +- deps/cxxopts/WORKSPACE | 16 + deps/cxxopts/cmake/cxxopts.cmake | 23 +- deps/cxxopts/include/cxxopts.hpp | 3624 +-- deps/cxxopts/packaging/pkgconfig.pc.in | 4 +- deps/cxxopts/src/CMakeLists.txt | 4 + deps/cxxopts/src/example.cpp | 33 +- deps/cxxopts/test/CMakeLists.txt | 11 + .../test/add-subdirectory-test/CMakeLists.txt | 5 +- deps/cxxopts/test/catch.hpp | 23529 ++++++++++------ .../test/find-package-test/CMakeLists.txt | 5 +- deps/cxxopts/test/fuzz.cpp | 107 + deps/cxxopts/test/options.cpp | 393 +- 19 files changed, 18225 insertions(+), 9819 deletions(-) create mode 100644 deps/cxxopts/test/fuzz.cpp diff --git a/deps/cxxopts/.github/workflows/cmake.yml b/deps/cxxopts/.github/workflows/cmake.yml index 3589fcb6f..2967916bb 100644 --- a/deps/cxxopts/.github/workflows/cmake.yml +++ b/deps/cxxopts/.github/workflows/cmake.yml @@ -2,43 +2,68 @@ name: CMake on: push: - branches: [ master ] + branches: [ master, main ] pull_request: - branches: [ master ] + branches: [ master, main ] workflow_dispatch: env: # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.) BUILD_TYPE: Release + +defaults: + run: + shell: bash + jobs: - build: - # The CMake configure and build commands are platform agnostic and should work equally - # well on Windows or Mac. You can convert this to a matrix build if you need - # cross-platform coverage. - # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix + build-ubuntu: + strategy: + matrix: + os: [ ubuntu-20.04, ubuntu-22.04 ] + compiler: [ g++-9, g++-10, clang++ ] + + name: Build and Test on Ubuntu runs-on: ${{matrix.os}} + steps: + - uses: actions/checkout@v3 + - name: Configure CMake + run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_CXX_COMPILER=${{matrix.compiler}} + - name: Build + run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE + - name: Test + working-directory: ${{github.workspace}}/build/test + run: ctest -C $BUILD_TYPE --output-on-failure + build-macos: + name: Build and Test on MacOS strategy: matrix: - os: [ubuntu-18.04] - compiler: [g++-7, g++-9, g++-10, clang++] - + os: [ macos-11, macos-12 ] + runs-on: ${{matrix.os}} + steps: + - uses: actions/checkout@v3 + - name: Configure CMake + run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_EXPORT_COMPILE_COMMANDS=ON + - name: Show compile commands + run: cat build/compile_commands.json + - name: Build + run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE + - name: Test + working-directory: ${{github.workspace}}/build/test + shell: bash + run: ctest -C $BUILD_TYPE --output-on-failure + + build-windows: + name: Build and Test on Windows + runs-on: windows-latest steps: - - uses: actions/checkout@v2 - - - name: Configure CMake - # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make. - # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type - run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_CXX_COMPILER=${{matrix.compiler}} - - - name: Build - # Build your program with the given configuration - run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} - - - name: Test - working-directory: ${{github.workspace}}/build - # Execute tests defined by the CMake configuration. - # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail - run: ctest -C ${{env.BUILD_TYPE}} - + - uses: actions/checkout@v3 + - uses: ilammy/msvc-dev-cmd@v1 + - name: Configure CMake + run: cmake -S "${{github.workspace}}" -B "${{github.workspace}}/build" -DCMAKE_BUILD_TYPE=$BUILD_TYPE -T "ClangCl" + - name: Build + run: cmake --build "${{github.workspace}}/build" --config $BUILD_TYPE + - name: Test + working-directory: ${{github.workspace}}/build/test + run: cd $BUILD_TYPE && ./link_test && ./options_test diff --git a/deps/cxxopts/.gitignore b/deps/cxxopts/.gitignore index 4038fb17e..65d8d32c1 100644 --- a/deps/cxxopts/.gitignore +++ b/deps/cxxopts/.gitignore @@ -1,9 +1,77 @@ +syntax: glob + +# Temporary, cache, swap files +\#\#* *.swp -build*/ +*.bkp + +# Files which "ask" to be hidden +*~ +.* +unused/ + +# Build artifacts +*.a +*.o +*.so +*.ptx +bin/* +lib/* +build/ +build-*/ +bazel-* + +# Core dumps +core +core.* +core-* + +# CMake & CTest-generated files CMakeCache.txt -Makefile CMakeFiles/ -Testing/ -CTestTestfile.cmake cmake_install.cmake -bazel-* +CMakeScripts/* +CMakeTmp/* +Makefile +CTestTestfile.cmake +Testing/ + +# Eclise IDE-related files +.project +.cproject +.settings + +# CLion IDE-related files +.idea/ +cmake-build-*/ + +# Patching +*.diff +*.rej +*.orig + +# Files/folders downloaded from other repositories as part of the build +external/* +third-party/* + +# Miscellaneous +tags +log +*.log +*.v3breakpoints +gmon.out +.DS_Store + +# Doxygen +doxygen.log +Doxyfile +docs/ + +# Archives +*.zip +*.gz +*.bz2 +*.tgz +*.tar +*.xz + diff --git a/deps/cxxopts/BUILD.bazel b/deps/cxxopts/BUILD.bazel index a66fae7d8..a6cd02143 100644 --- a/deps/cxxopts/BUILD.bazel +++ b/deps/cxxopts/BUILD.bazel @@ -6,3 +6,11 @@ cc_library( strip_include_prefix = "include", visibility = ["//visibility:public"], ) + +load("@rules_fuzzing//fuzzing:cc_defs.bzl", "cc_fuzz_test") + +cc_fuzz_test( + name = "cxxopts_fuzz_test", + srcs = ["test/fuzz.cpp"], + deps = [":cxxopts"], +) \ No newline at end of file diff --git a/deps/cxxopts/CHANGELOG.md b/deps/cxxopts/CHANGELOG.md index 220717d03..0c7648694 100644 --- a/deps/cxxopts/CHANGELOG.md +++ b/deps/cxxopts/CHANGELOG.md @@ -3,11 +3,55 @@ This is the changelog for `cxxopts`, a C++11 library for parsing command line options. The project adheres to semantic versioning. -## Unreleased +## 3.2.1 + +### Bug fixes + +* Fix compilation with optional on C++20. + +## 3.2 + +### Bug fixes + +* Fix unannotated fallthrough. +* Fix sign conversion with Unicode output. +* Don't initialize regex in static initialiser. +* Fix incorrect integer overflow checks. + +### Added + +* Add fuzzing to CI + +### Changed + +* Change quote output to '' to match Windows. +* Don't split positional arguments by the list delimiter. +* Order help groups by the order they were added. + +## 3.1.1 + +### Bug Fixes + +* Fixed version number in header. +* Fixed cast warning in Unicode function. + +## 3.1 ### Added +* Support for multiple long names for the same option (= multiple long aliases) * Add a `program()` function to retrieve the program name. +* Added a .clang-format file. +* Added iterator and printing for a ParseResult. + +### Changed + +* Cleanup exception code, add cxxopts::exceptions namespace. +* Renamed several exceptions to be more descriptive, and added to a nested namespace. + +### Bug Fixes + +* Fix `arguments()` having no key for options that only have a short name. ## 3.0 diff --git a/deps/cxxopts/CMakeLists.txt b/deps/cxxopts/CMakeLists.txt index 4c1a68606..110d3dd79 100644 --- a/deps/cxxopts/CMakeLists.txt +++ b/deps/cxxopts/CMakeLists.txt @@ -17,12 +17,10 @@ # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. -cmake_minimum_required(VERSION 3.1...3.19) +cmake_minimum_required(VERSION 3.5...3.19) list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake/") include(cxxopts) -set("PROJECT_DESCRIPTION" "A header-only lightweight C++ command line option parser") -set("PROJECT_HOMEPAGE_URL" "https://github.com/jarro2783/cxxopts") # Get the version of the library cxxopts_getversion(VERSION) @@ -32,6 +30,9 @@ project(cxxopts LANGUAGES CXX ) +set("PROJECT_DESCRIPTION" "A header-only lightweight C++ command line option parser") +set("PROJECT_HOMEPAGE_URL" "https://github.com/jarro2783/cxxopts") + # Must include after the project call due to GNUInstallDirs requiring a language be enabled (IE. CXX) include(GNUInstallDirs) diff --git a/deps/cxxopts/INSTALL b/deps/cxxopts/INSTALL index 3e1c6f3da..de7b0a813 100644 --- a/deps/cxxopts/INSTALL +++ b/deps/cxxopts/INSTALL @@ -21,3 +21,26 @@ To run the tests, you have to configure `cxxopts` with another flag: cmake -D CXXOPTS_BUILD_TESTS=On ${CXXOPTS_DIR} make make test + +== Using cxxopts in tipi.build projects == + +`cxxopts` can be easily used in [tipi.build](https://tipi.build) projects simply by adding the following entry to your `.tipi/deps`: + +```json +{ + "jarro2783/cxxopts": { "@": "v3.0.0" } +} +``` + +To try this you can run the following command in `/src` (change the target name appropriately to `linux` or `macos` or `windows`): + +```bash +tipi . -t +./build/linux-cxx17/bin/test_package -v +``` + +To develop `cxxopts` using tipi run the following command at the root of the repository: + +```bash +tipi . -t --test all -v +``` diff --git a/deps/cxxopts/README.md b/deps/cxxopts/README.md index ede30ef4d..603e4350c 100644 --- a/deps/cxxopts/README.md +++ b/deps/cxxopts/README.md @@ -85,9 +85,6 @@ result["opt"].as() to get its value. If "opt" doesn't exist, or isn't of the right type, then an exception will be thrown. -Note that the result of `options.parse` should only be used as long as the -`options` object that created it is in scope. - ## Unrecognised arguments You can allow unrecognised arguments to be skipped. This applies to both @@ -109,9 +106,9 @@ result.unmatched() Exceptional situations throw C++ exceptions. There are two types of exceptions: errors defining the options, and errors when parsing a list of -arguments. All exceptions derive from `cxxopts::OptionException`. Errors -defining options derive from `cxxopts::OptionSpecException` and errors -parsing arguments derive from `cxxopts::OptionParseException`. +arguments. All exceptions derive from `cxxopts::exceptions::exception`. Errors +defining options derive from `cxxopts::exceptions::specification` and errors +parsing arguments derive from `cxxopts::exceptions::parsing`. All exceptions define a `what()` function to get a printable string explaining the error. @@ -125,15 +122,37 @@ vector to the `help` function. ## Positional Arguments -Positional arguments can be optionally parsed into one or more options. -To set up positional arguments, call +Positional arguments are those given without a preceding flag and can be used +alongside non-positional arguments. There may be multiple positional arguments, +and the final positional argument may be a container type to hold a list of all +remaining positionals. + +To set up positional arguments, first declare the options, then configure a +set of those arguments as positional like: ```cpp -options.parse_positional({"first", "second", "last"}) +options.add_options() + ("script", "The script file to execute", cxxopts::value()) + ("server", "The server to execute on", cxxopts::value()) + ("filenames", "The filename(s) to process", cxxopts::value>()); + +options.parse_positional({"script", "server", "filenames"}); + +// Parse options the usual way +options.parse(argc, argv); ``` -where "last" should be the name of an option with a container type, and the -others should have a single value. +For example, parsing the following arguments: +~~~ +my_script.py my_server.com file1.txt file2.txt file3.txt +~~~ +will result in parsed arguments like the following table: + +| Field | Value | +| ------------- | ----------------------------------------- | +| `"script"` | `"my_script.py"` | +| `"server"` | `"my_server.com"` | +| `"filenames"` | `{"file1.txt", "file2.txt", "file3.txt"}` | ## Default and implicit values @@ -174,8 +193,8 @@ therefore, `-o false` does not work. ## `std::vector` values -Parsing of list of values in form of an `std::vector` is also supported, as long as `T` -can be parsed. To separate single values in a list the definition `CXXOPTS_VECTOR_DELIMITER` +Parsing a list of values into a `std::vector` is also supported, as long as `T` +can be parsed. To separate single values in a list the define symbol `CXXOPTS_VECTOR_DELIMITER` is used, which is ',' by default. Ensure that you use no whitespaces between values because those would be interpreted as the next command line option. Example for a command line option that can be parsed as a `std::vector`: @@ -256,7 +275,3 @@ GCC >= 4.9 or clang >= 3.1 with libc++ are known to work. The following compilers are known not to work: * MSVC 2013 - -# TODO list - -* Allow unrecognised options. diff --git a/deps/cxxopts/WORKSPACE b/deps/cxxopts/WORKSPACE index e69de29bb..6a0fa2770 100644 --- a/deps/cxxopts/WORKSPACE +++ b/deps/cxxopts/WORKSPACE @@ -0,0 +1,16 @@ +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "rules_fuzzing", + sha256 = "d9002dd3cd6437017f08593124fdd1b13b3473c7b929ceb0e60d317cb9346118", + strip_prefix = "rules_fuzzing-0.3.2", + urls = ["https://github.com/bazelbuild/rules_fuzzing/archive/v0.3.2.zip"], +) + +load("@rules_fuzzing//fuzzing:repositories.bzl", "rules_fuzzing_dependencies") + +rules_fuzzing_dependencies() + +load("@rules_fuzzing//fuzzing:init.bzl", "rules_fuzzing_init") + +rules_fuzzing_init() diff --git a/deps/cxxopts/cmake/cxxopts.cmake b/deps/cxxopts/cmake/cxxopts.cmake index 46e87ba60..b26c18a8e 100644 --- a/deps/cxxopts/cmake/cxxopts.cmake +++ b/deps/cxxopts/cmake/cxxopts.cmake @@ -87,18 +87,25 @@ endfunction() # Helper function to ecapsulate install logic function(cxxopts_install_logic) - string(REPLACE "/${CMAKE_LIBRARY_ARCHITECTURE}" "" CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_LIBDIR}") + if(NOT CXXOPTS_USE_UNICODE_HELP) + if(CMAKE_LIBRARY_ARCHITECTURE) + string(REPLACE "/${CMAKE_LIBRARY_ARCHITECTURE}" "" CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_LIBDIR}") + else() + # On some systems (e.g. NixOS), `CMAKE_LIBRARY_ARCHITECTURE` can be empty + set(CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_DATAROOTDIR}") + endif() + if(${CMAKE_VERSION} VERSION_GREATER "3.14") + set(OPTIONAL_ARCH_INDEPENDENT "ARCH_INDEPENDENT") + endif() + else() + set(CMAKE_INSTALL_LIBDIR_ARCHIND "${CMAKE_INSTALL_LIBDIR}") + endif() set(CXXOPTS_CMAKE_DIR "${CMAKE_INSTALL_LIBDIR_ARCHIND}/cmake/cxxopts" CACHE STRING "Installation directory for cmake files, relative to ${CMAKE_INSTALL_PREFIX}.") set(version_config "${PROJECT_BINARY_DIR}/cxxopts-config-version.cmake") set(project_config "${PROJECT_BINARY_DIR}/cxxopts-config.cmake") set(targets_export_name cxxopts-targets) set(PackagingTemplatesDir "${PROJECT_SOURCE_DIR}/packaging") - - if(${CMAKE_VERSION} VERSION_GREATER "3.14") - set(OPTIONAL_ARCH_INDEPENDENT "ARCH_INDEPENDENT") - endif() - # Generate the version, config and target files into the build directory. write_basic_package_version_file( ${version_config} @@ -149,6 +156,10 @@ function(cxxopts_install_logic) set(CPACK_DEBIAN_COMPRESSION_TYPE "xz") set(PKG_CONFIG_FILE_NAME "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc") + if(CXXOPTS_USE_UNICODE_HELP) + set(PKG_CONFIG_REQUIRES "icu-cu") + set(PKG_CONFIG_EXTRA_CFLAGS "-DCXXOPTS_USE_UNICODE") + endif() configure_file("${PackagingTemplatesDir}/pkgconfig.pc.in" "${PKG_CONFIG_FILE_NAME}" @ONLY) install(FILES "${PKG_CONFIG_FILE_NAME}" DESTINATION "${CMAKE_INSTALL_LIBDIR_ARCHIND}/pkgconfig" diff --git a/deps/cxxopts/include/cxxopts.hpp b/deps/cxxopts/include/cxxopts.hpp index 2dd4da6b7..63d140dc8 100644 --- a/deps/cxxopts/include/cxxopts.hpp +++ b/deps/cxxopts/include/cxxopts.hpp @@ -1,6 +1,6 @@ /* -Copyright (c) 2014, 2015, 2016, 2017 Jarryd Beck +Copyright (c) 2014-2022 Jarryd Beck Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -22,15 +22,17 @@ THE SOFTWARE. */ +// vim: ts=2:sw=2:expandtab + #ifndef CXXOPTS_HPP_INCLUDED #define CXXOPTS_HPP_INCLUDED -#include +#include +#include #include #include -#include #include -#include +#include #include #include #include @@ -40,12 +42,24 @@ THE SOFTWARE. #include #include #include +#include + +#ifdef CXXOPTS_NO_EXCEPTIONS +#include +#endif #if defined(__GNUC__) && !defined(__clang__) # if (__GNUC__ * 10 + __GNUC_MINOR__) < 49 # define CXXOPTS_NO_REGEX true # endif #endif +#if defined(_MSC_VER) && !defined(__clang__) +#define CXXOPTS_LINKONCE_CONST __declspec(selectany) extern +#define CXXOPTS_LINKONCE __declspec(selectany) extern +#else +#define CXXOPTS_LINKONCE_CONST +#define CXXOPTS_LINKONCE +#endif #ifndef CXXOPTS_NO_REGEX # include @@ -59,6 +73,20 @@ THE SOFTWARE. # define CXXOPTS_HAS_OPTIONAL # endif # endif +# if __has_include() +# include +# ifdef __cpp_lib_filesystem +# define CXXOPTS_HAS_FILESYSTEM +# endif +# endif +#endif + +#define CXXOPTS_FALLTHROUGH +#ifdef __has_cpp_attribute + #if __has_cpp_attribute(fallthrough) + #undef CXXOPTS_FALLTHROUGH + #define CXXOPTS_FALLTHROUGH [[fallthrough]] + #endif #endif #if __cplusplus >= 201603L @@ -72,22 +100,39 @@ THE SOFTWARE. #endif #define CXXOPTS__VERSION_MAJOR 3 -#define CXXOPTS__VERSION_MINOR 0 -#define CXXOPTS__VERSION_PATCH 0 +#define CXXOPTS__VERSION_MINOR 2 +#define CXXOPTS__VERSION_PATCH 1 #if (__GNUC__ < 10 || (__GNUC__ == 10 && __GNUC_MINOR__ < 1)) && __GNUC__ >= 6 #define CXXOPTS_NULL_DEREF_IGNORE #endif -namespace cxxopts -{ - static constexpr struct { - uint8_t major, minor, patch; - } version = { - CXXOPTS__VERSION_MAJOR, - CXXOPTS__VERSION_MINOR, - CXXOPTS__VERSION_PATCH - }; +#if defined(__GNUC__) +#define DO_PRAGMA(x) _Pragma(#x) +#define CXXOPTS_DIAGNOSTIC_PUSH DO_PRAGMA(GCC diagnostic push) +#define CXXOPTS_DIAGNOSTIC_POP DO_PRAGMA(GCC diagnostic pop) +#define CXXOPTS_IGNORE_WARNING(x) DO_PRAGMA(GCC diagnostic ignored x) +#else +// define other compilers here if needed +#define CXXOPTS_DIAGNOSTIC_PUSH +#define CXXOPTS_DIAGNOSTIC_POP +#define CXXOPTS_IGNORE_WARNING(x) +#endif + +#ifdef CXXOPTS_NO_RTTI +#define CXXOPTS_RTTI_CAST static_cast +#else +#define CXXOPTS_RTTI_CAST dynamic_cast +#endif + +namespace cxxopts { +static constexpr struct { + uint8_t major, minor, patch; +} version = { + CXXOPTS__VERSION_MAJOR, + CXXOPTS__VERSION_MINOR, + CXXOPTS__VERSION_PATCH +}; } // namespace cxxopts //when we ask cxxopts to use Unicode, help strings are processed using ICU, @@ -99,1984 +144,2168 @@ namespace cxxopts #ifdef CXXOPTS_USE_UNICODE #include -namespace cxxopts -{ - using String = icu::UnicodeString; +namespace cxxopts { - inline - String - toLocalString(std::string s) - { - return icu::UnicodeString::fromUTF8(std::move(s)); - } +using String = icu::UnicodeString; + +inline +String +toLocalString(std::string s) +{ + return icu::UnicodeString::fromUTF8(std::move(s)); +} -#if defined(__GNUC__) // GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it: // warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" -#pragma GCC diagnostic ignored "-Weffc++" +CXXOPTS_DIAGNOSTIC_PUSH +CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor") // This will be ignored under other compilers like LLVM clang. -#endif - class UnicodeStringIterator : public - std::iterator - { - public: - - UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos) - : s(string) - , i(pos) - { - } - - value_type - operator*() const - { - return s->char32At(i); - } - - bool - operator==(const UnicodeStringIterator& rhs) const - { - return s == rhs.s && i == rhs.i; - } - - bool - operator!=(const UnicodeStringIterator& rhs) const - { - return !(*this == rhs); - } - - UnicodeStringIterator& - operator++() - { - ++i; - return *this; - } - - UnicodeStringIterator - operator+(int32_t v) - { - return UnicodeStringIterator(s, i + v); - } +class UnicodeStringIterator +{ + public: - private: - const icu::UnicodeString* s; - int32_t i; - }; -#if defined(__GNUC__) -#pragma GCC diagnostic pop -#endif + using iterator_category = std::forward_iterator_tag; + using value_type = int32_t; + using difference_type = std::ptrdiff_t; + using pointer = value_type*; + using reference = value_type&; - inline - String& - stringAppend(String&s, String a) + UnicodeStringIterator(const icu::UnicodeString* string, int32_t pos) + : s(string) + , i(pos) { - return s.append(std::move(a)); } - inline - String& - stringAppend(String& s, size_t n, UChar32 c) + value_type + operator*() const { - for (size_t i = 0; i != n; ++i) - { - s.append(c); - } - - return s; + return s->char32At(i); } - template - String& - stringAppend(String& s, Iterator begin, Iterator end) + bool + operator==(const UnicodeStringIterator& rhs) const { - while (begin != end) - { - s.append(*begin); - ++begin; - } - - return s; + return s == rhs.s && i == rhs.i; } - inline - size_t - stringLength(const String& s) + bool + operator!=(const UnicodeStringIterator& rhs) const { - return s.length(); + return !(*this == rhs); } - inline - std::string - toUTF8String(const String& s) + UnicodeStringIterator& + operator++() { - std::string result; - s.toUTF8String(result); - - return result; + ++i; + return *this; } - inline - bool - empty(const String& s) + UnicodeStringIterator + operator+(int32_t v) { - return s.isEmpty(); + return UnicodeStringIterator(s, i + v); } + + private: + const icu::UnicodeString* s; + int32_t i; +}; +CXXOPTS_DIAGNOSTIC_POP + +inline +String& +stringAppend(String&s, String a) +{ + return s.append(std::move(a)); } -namespace std +inline +String& +stringAppend(String& s, std::size_t n, UChar32 c) { - inline - cxxopts::UnicodeStringIterator - begin(const icu::UnicodeString& s) + for (std::size_t i = 0; i != n; ++i) { - return cxxopts::UnicodeStringIterator(&s, 0); + s.append(c); } - inline - cxxopts::UnicodeStringIterator - end(const icu::UnicodeString& s) + return s; +} + +template +String& +stringAppend(String& s, Iterator begin, Iterator end) +{ + while (begin != end) { - return cxxopts::UnicodeStringIterator(&s, s.length()); + s.append(*begin); + ++begin; } + + return s; +} + +inline +size_t +stringLength(const String& s) +{ + return static_cast(s.length()); +} + +inline +std::string +toUTF8String(const String& s) +{ + std::string result; + s.toUTF8String(result); + + return result; +} + +inline +bool +empty(const String& s) +{ + return s.isEmpty(); +} + +} // namespace cxxopts + +namespace std { + +inline +cxxopts::UnicodeStringIterator +begin(const icu::UnicodeString& s) +{ + return cxxopts::UnicodeStringIterator(&s, 0); } +inline +cxxopts::UnicodeStringIterator +end(const icu::UnicodeString& s) +{ + return cxxopts::UnicodeStringIterator(&s, s.length()); +} + +} // namespace std + //ifdef CXXOPTS_USE_UNICODE #else -namespace cxxopts +namespace cxxopts { + +using String = std::string; + +template +T +toLocalString(T&& t) { - using String = std::string; + return std::forward(t); +} - template - T - toLocalString(T&& t) - { - return std::forward(t); - } +inline +std::size_t +stringLength(const String& s) +{ + return s.length(); +} - inline - size_t - stringLength(const String& s) - { - return s.length(); - } +inline +String& +stringAppend(String&s, const String& a) +{ + return s.append(a); +} - inline - String& - stringAppend(String&s, const String& a) - { - return s.append(a); - } +inline +String& +stringAppend(String& s, std::size_t n, char c) +{ + return s.append(n, c); +} - inline - String& - stringAppend(String& s, size_t n, char c) - { - return s.append(n, c); - } +template +String& +stringAppend(String& s, Iterator begin, Iterator end) +{ + return s.append(begin, end); +} - template - String& - stringAppend(String& s, Iterator begin, Iterator end) - { - return s.append(begin, end); - } +template +std::string +toUTF8String(T&& t) +{ + return std::forward(t); +} - template - std::string - toUTF8String(T&& t) - { - return std::forward(t); - } +inline +bool +empty(const std::string& s) +{ + return s.empty(); +} - inline - bool - empty(const std::string& s) - { - return s.empty(); - } } // namespace cxxopts //ifdef CXXOPTS_USE_UNICODE #endif -namespace cxxopts -{ - namespace - { -#ifdef _WIN32 - const std::string LQUOTE("\'"); - const std::string RQUOTE("\'"); -#else - const std::string LQUOTE("‘"); - const std::string RQUOTE("’"); -#endif - } // namespace +namespace cxxopts { -#if defined(__GNUC__) -// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we want to silence it: -// warning: base class 'class std::enable_shared_from_this' has accessible non-virtual destructor -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wnon-virtual-dtor" -#pragma GCC diagnostic ignored "-Weffc++" -// This will be ignored under other compilers like LLVM clang. -#endif - class Value : public std::enable_shared_from_this - { - public: +namespace { +CXXOPTS_LINKONCE_CONST std::string LQUOTE("\'"); +CXXOPTS_LINKONCE_CONST std::string RQUOTE("\'"); +} // namespace - virtual ~Value() = default; +// GNU GCC with -Weffc++ will issue a warning regarding the upcoming class, we +// want to silence it: warning: base class 'class +// std::enable_shared_from_this' has accessible non-virtual +// destructor This will be ignored under other compilers like LLVM clang. +CXXOPTS_DIAGNOSTIC_PUSH +CXXOPTS_IGNORE_WARNING("-Wnon-virtual-dtor") - virtual - std::shared_ptr - clone() const = 0; +// some older versions of GCC warn under this warning +CXXOPTS_IGNORE_WARNING("-Weffc++") +class Value : public std::enable_shared_from_this +{ + public: - virtual void - parse(const std::string& text) const = 0; + virtual ~Value() = default; - virtual void - parse() const = 0; + virtual + std::shared_ptr + clone() const = 0; - virtual bool - has_default() const = 0; + virtual void + add(const std::string& text) const = 0; - virtual bool - is_container() const = 0; + virtual void + parse(const std::string& text) const = 0; - virtual bool - has_implicit() const = 0; + virtual void + parse() const = 0; - virtual std::string - get_default_value() const = 0; + virtual bool + has_default() const = 0; - virtual std::string - get_implicit_value() const = 0; + virtual bool + is_container() const = 0; - virtual std::shared_ptr - default_value(const std::string& value) = 0; + virtual bool + has_implicit() const = 0; - virtual std::shared_ptr - implicit_value(const std::string& value) = 0; + virtual std::string + get_default_value() const = 0; - virtual std::shared_ptr - no_implicit_value() = 0; + virtual std::string + get_implicit_value() const = 0; - virtual bool - is_boolean() const = 0; - }; -#if defined(__GNUC__) -#pragma GCC diagnostic pop -#endif - class OptionException : public std::exception - { - public: - explicit OptionException(std::string message) - : m_message(std::move(message)) - { - } + virtual std::shared_ptr + default_value(const std::string& value) = 0; - CXXOPTS_NODISCARD - const char* - what() const noexcept override - { - return m_message.c_str(); - } + virtual std::shared_ptr + implicit_value(const std::string& value) = 0; - private: - std::string m_message; - }; + virtual std::shared_ptr + no_implicit_value() = 0; - class OptionSpecException : public OptionException - { - public: + virtual bool + is_boolean() const = 0; +}; - explicit OptionSpecException(const std::string& message) - : OptionException(message) - { - } - }; +CXXOPTS_DIAGNOSTIC_POP - class OptionParseException : public OptionException - { - public: - explicit OptionParseException(const std::string& message) - : OptionException(message) - { - } - }; +namespace exceptions { - class option_exists_error : public OptionSpecException +class exception : public std::exception +{ + public: + explicit exception(std::string message) + : m_message(std::move(message)) { - public: - explicit option_exists_error(const std::string& option) - : OptionSpecException("Option " + LQUOTE + option + RQUOTE + " already exists") - { - } - }; + } - class invalid_option_format_error : public OptionSpecException + CXXOPTS_NODISCARD + const char* + what() const noexcept override { - public: - explicit invalid_option_format_error(const std::string& format) - : OptionSpecException("Invalid option format " + LQUOTE + format + RQUOTE) - { - } - }; + return m_message.c_str(); + } - class option_syntax_exception : public OptionParseException { - public: - explicit option_syntax_exception(const std::string& text) - : OptionParseException("Argument " + LQUOTE + text + RQUOTE + - " starts with a - but has incorrect syntax") - { - } - }; + private: + std::string m_message; +}; - class option_not_exists_exception : public OptionParseException - { - public: - explicit option_not_exists_exception(const std::string& option) - : OptionParseException("Option " + LQUOTE + option + RQUOTE + " does not exist") - { - } - }; +class specification : public exception +{ + public: - class missing_argument_exception : public OptionParseException + explicit specification(const std::string& message) + : exception(message) { - public: - explicit missing_argument_exception(const std::string& option) - : OptionParseException( - "Option " + LQUOTE + option + RQUOTE + " is missing an argument" - ) - { - } - }; + } +}; - class option_requires_argument_exception : public OptionParseException +class parsing : public exception +{ + public: + explicit parsing(const std::string& message) + : exception(message) { - public: - explicit option_requires_argument_exception(const std::string& option) - : OptionParseException( - "Option " + LQUOTE + option + RQUOTE + " requires an argument" - ) - { - } - }; + } +}; - class option_not_has_argument_exception : public OptionParseException +class option_already_exists : public specification +{ + public: + explicit option_already_exists(const std::string& option) + : specification("Option " + LQUOTE + option + RQUOTE + " already exists") { - public: - option_not_has_argument_exception - ( - const std::string& option, - const std::string& arg - ) - : OptionParseException( - "Option " + LQUOTE + option + RQUOTE + - " does not take an argument, but argument " + - LQUOTE + arg + RQUOTE + " given" - ) - { - } - }; + } +}; - class option_not_present_exception : public OptionParseException +class invalid_option_format : public specification +{ + public: + explicit invalid_option_format(const std::string& format) + : specification("Invalid option format " + LQUOTE + format + RQUOTE) { - public: - explicit option_not_present_exception(const std::string& option) - : OptionParseException("Option " + LQUOTE + option + RQUOTE + " not present") - { - } - }; + } +}; - class option_has_no_value_exception : public OptionException +class invalid_option_syntax : public parsing { + public: + explicit invalid_option_syntax(const std::string& text) + : parsing("Argument " + LQUOTE + text + RQUOTE + + " starts with a - but has incorrect syntax") { - public: - explicit option_has_no_value_exception(const std::string& option) - : OptionException( - !option.empty() ? - ("Option " + LQUOTE + option + RQUOTE + " has no value") : - "Option has no value") - { - } - }; + } +}; - class argument_incorrect_type : public OptionParseException +class no_such_option : public parsing +{ + public: + explicit no_such_option(const std::string& option) + : parsing("Option " + LQUOTE + option + RQUOTE + " does not exist") { - public: - explicit argument_incorrect_type - ( - const std::string& arg - ) - : OptionParseException( - "Argument " + LQUOTE + arg + RQUOTE + " failed to parse" - ) - { - } - }; + } +}; - class option_required_exception : public OptionParseException +class missing_argument : public parsing +{ + public: + explicit missing_argument(const std::string& option) + : parsing( + "Option " + LQUOTE + option + RQUOTE + " is missing an argument" + ) { - public: - explicit option_required_exception(const std::string& option) - : OptionParseException( - "Option " + LQUOTE + option + RQUOTE + " is required but not present" - ) - { - } - }; + } +}; - template - void throw_or_mimic(const std::string& text) +class option_requires_argument : public parsing +{ + public: + explicit option_requires_argument(const std::string& option) + : parsing( + "Option " + LQUOTE + option + RQUOTE + " requires an argument" + ) { - static_assert(std::is_base_of::value, - "throw_or_mimic only works on std::exception and " - "deriving classes"); - -#ifndef CXXOPTS_NO_EXCEPTIONS - // If CXXOPTS_NO_EXCEPTIONS is not defined, just throw - throw T{text}; -#else - // Otherwise manually instantiate the exception, print what() to stderr, - // and exit - T exception{text}; - std::cerr << exception.what() << std::endl; - std::exit(EXIT_FAILURE); -#endif } +}; + +class gratuitous_argument_for_option : public parsing +{ + public: + gratuitous_argument_for_option + ( + const std::string& option, + const std::string& arg + ) + : parsing( + "Option " + LQUOTE + option + RQUOTE + + " does not take an argument, but argument " + + LQUOTE + arg + RQUOTE + " given" + ) + { + } +}; + +class requested_option_not_present : public parsing +{ + public: + explicit requested_option_not_present(const std::string& option) + : parsing("Option " + LQUOTE + option + RQUOTE + " not present") + { + } +}; + +class option_has_no_value : public exception +{ + public: + explicit option_has_no_value(const std::string& option) + : exception( + !option.empty() ? + ("Option " + LQUOTE + option + RQUOTE + " has no value") : + "Option has no value") + { + } +}; + +class incorrect_argument_type : public parsing +{ + public: + explicit incorrect_argument_type + ( + const std::string& arg + ) + : parsing( + "Argument " + LQUOTE + arg + RQUOTE + " failed to parse" + ) + { + } +}; + +} // namespace exceptions + + +template +void throw_or_mimic(const std::string& text) +{ + static_assert(std::is_base_of::value, + "throw_or_mimic only works on std::exception and " + "deriving classes"); + +#ifndef CXXOPTS_NO_EXCEPTIONS + // If CXXOPTS_NO_EXCEPTIONS is not defined, just throw + throw T{text}; +#else + // Otherwise manually instantiate the exception, print what() to stderr, + // and exit + T exception{text}; + std::cerr << exception.what() << std::endl; + std::exit(EXIT_FAILURE); +#endif +} + +using OptionNames = std::vector; + +namespace values { + +namespace parser_tool { + +struct IntegerDesc +{ + std::string negative = ""; + std::string base = ""; + std::string value = ""; +}; +struct ArguDesc { + std::string arg_name = ""; + bool grouping = false; + bool set_value = false; + std::string value = ""; +}; - namespace values - { - namespace parser_tool - { - struct IntegerDesc - { - std::string negative = ""; - std::string base = ""; - std::string value = ""; - }; - struct ArguDesc { - std::string arg_name = ""; - bool grouping = false; - bool set_value = false; - std::string value = ""; - }; #ifdef CXXOPTS_NO_REGEX - inline IntegerDesc SplitInteger(const std::string &text) - { - if (text.empty()) - { - throw_or_mimic(text); - } - IntegerDesc desc; - const char *pdata = text.c_str(); - if (*pdata == '-') - { - pdata += 1; - desc.negative = "-"; - } - if (strncmp(pdata, "0x", 2) == 0) - { - pdata += 2; - desc.base = "0x"; - } - if (*pdata != '\0') - { - desc.value = std::string(pdata); - } - else - { - throw_or_mimic(text); - } - return desc; - } +inline IntegerDesc SplitInteger(const std::string &text) +{ + if (text.empty()) + { + throw_or_mimic(text); + } + IntegerDesc desc; + const char *pdata = text.c_str(); + if (*pdata == '-') + { + pdata += 1; + desc.negative = "-"; + } + if (strncmp(pdata, "0x", 2) == 0) + { + pdata += 2; + desc.base = "0x"; + } + if (*pdata != '\0') + { + desc.value = std::string(pdata); + } + else + { + throw_or_mimic(text); + } + return desc; +} - inline bool IsTrueText(const std::string &text) - { - const char *pdata = text.c_str(); - if (*pdata == 't' || *pdata == 'T') - { - pdata += 1; - if (strncmp(pdata, "rue\0", 4) == 0) - { - return true; - } - } - else if (strncmp(pdata, "1\0", 2) == 0) - { - return true; - } - return false; - } +inline bool IsTrueText(const std::string &text) +{ + const char *pdata = text.c_str(); + if (*pdata == 't' || *pdata == 'T') + { + pdata += 1; + if (strncmp(pdata, "rue\0", 4) == 0) + { + return true; + } + } + else if (strncmp(pdata, "1\0", 2) == 0) + { + return true; + } + return false; +} - inline bool IsFalseText(const std::string &text) - { - const char *pdata = text.c_str(); - if (*pdata == 'f' || *pdata == 'F') - { - pdata += 1; - if (strncmp(pdata, "alse\0", 5) == 0) - { - return true; - } - } - else if (strncmp(pdata, "0\0", 2) == 0) - { - return true; - } - return false; +inline bool IsFalseText(const std::string &text) +{ + const char *pdata = text.c_str(); + if (*pdata == 'f' || *pdata == 'F') + { + pdata += 1; + if (strncmp(pdata, "alse\0", 5) == 0) + { + return true; + } + } + else if (strncmp(pdata, "0\0", 2) == 0) + { + return true; + } + return false; +} + +inline OptionNames split_option_names(const std::string &text) +{ + OptionNames split_names; + + std::string::size_type token_start_pos = 0; + auto length = text.length(); + + if (length == 0) + { + throw_or_mimic(text); + } + + while (token_start_pos < length) { + const auto &npos = std::string::npos; + auto next_non_space_pos = text.find_first_not_of(' ', token_start_pos); + if (next_non_space_pos == npos) { + throw_or_mimic(text); + } + token_start_pos = next_non_space_pos; + auto next_delimiter_pos = text.find(',', token_start_pos); + if (next_delimiter_pos == token_start_pos) { + throw_or_mimic(text); + } + if (next_delimiter_pos == npos) { + next_delimiter_pos = length; + } + auto token_length = next_delimiter_pos - token_start_pos; + // validate the token itself matches the regex /([:alnum:][-_[:alnum:]]*/ + { + const char* option_name_valid_chars = + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghijklmnopqrstuvwxyz" + "0123456789" + "_-.?"; + + if (!std::isalnum(text[token_start_pos], std::locale::classic()) || + text.find_first_not_of(option_name_valid_chars, token_start_pos) < next_delimiter_pos) { + throw_or_mimic(text); } + } + split_names.emplace_back(text.substr(token_start_pos, token_length)); + token_start_pos = next_delimiter_pos + 1; + } + return split_names; +} - inline std::pair SplitSwitchDef(const std::string &text) +inline ArguDesc ParseArgument(const char *arg, bool &matched) +{ + ArguDesc argu_desc; + const char *pdata = arg; + matched = false; + if (strncmp(pdata, "--", 2) == 0) + { + pdata += 2; + if (isalnum(*pdata, std::locale::classic())) + { + argu_desc.arg_name.push_back(*pdata); + pdata += 1; + while (isalnum(*pdata, std::locale::classic()) || *pdata == '-' || *pdata == '_') { - std::string short_sw, long_sw; - const char *pdata = text.c_str(); - if (isalnum(*pdata) && *(pdata + 1) == ',') { - short_sw = std::string(1, *pdata); - pdata += 2; - } - while (*pdata == ' ') { pdata += 1; } - if (isalnum(*pdata)) { - const char *store = pdata; - pdata += 1; - while (isalnum(*pdata) || *pdata == '-' || *pdata == '_') { - pdata += 1; - } - if (*pdata == '\0') { - long_sw = std::string(store, pdata - store); - } else { - throw_or_mimic(text); - } - } - return std::pair(short_sw, long_sw); + argu_desc.arg_name.push_back(*pdata); + pdata += 1; } - - inline ArguDesc ParseArgument(const char *arg, bool &matched) + if (argu_desc.arg_name.length() > 1) { - ArguDesc argu_desc; - const char *pdata = arg; - matched = false; - if (strncmp(pdata, "--", 2) == 0) + if (*pdata == '=') { - pdata += 2; - if (isalnum(*pdata)) + argu_desc.set_value = true; + pdata += 1; + if (*pdata != '\0') { - argu_desc.arg_name.push_back(*pdata); - pdata += 1; - while (isalnum(*pdata) || *pdata == '-' || *pdata == '_') - { - argu_desc.arg_name.push_back(*pdata); - pdata += 1; - } - if (argu_desc.arg_name.length() > 1) - { - if (*pdata == '=') - { - argu_desc.set_value = true; - pdata += 1; - if (*pdata != '\0') - { - argu_desc.value = std::string(pdata); - } - matched = true; - } - else if (*pdata == '\0') - { - matched = true; - } - } + argu_desc.value = std::string(pdata); } + matched = true; } - else if (strncmp(pdata, "-", 1) == 0) + else if (*pdata == '\0') { - pdata += 1; - argu_desc.grouping = true; - while (isalnum(*pdata)) - { - argu_desc.arg_name.push_back(*pdata); - pdata += 1; - } - matched = !argu_desc.arg_name.empty() && *pdata == '\0'; + matched = true; } - return argu_desc; } + } + } + else if (strncmp(pdata, "-", 1) == 0) + { + pdata += 1; + argu_desc.grouping = true; + while (isalnum(*pdata, std::locale::classic())) + { + argu_desc.arg_name.push_back(*pdata); + pdata += 1; + } + matched = !argu_desc.arg_name.empty() && *pdata == '\0'; + } + return argu_desc; +} #else // CXXOPTS_NO_REGEX - namespace - { - - std::basic_regex integer_pattern - ("(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)"); - std::basic_regex truthy_pattern - ("(t|T)(rue)?|1"); - std::basic_regex falsy_pattern - ("(f|F)(alse)?|0"); - - std::basic_regex option_matcher - ("--([[:alnum:]][-_[:alnum:]]+)(=(.*))?|-([[:alnum:]]+)"); - std::basic_regex option_specifier - ("(([[:alnum:]]),)?[ ]*([[:alnum:]][-_[:alnum:]]*)?"); +namespace { +CXXOPTS_LINKONCE +const char* const integer_pattern = + "(-)?(0x)?([0-9a-zA-Z]+)|((0x)?0)"; +CXXOPTS_LINKONCE +const char* const truthy_pattern = + "(t|T)(rue)?|1"; +CXXOPTS_LINKONCE +const char* const falsy_pattern = + "(f|F)(alse)?|0"; +CXXOPTS_LINKONCE +const char* const option_pattern = + "--([[:alnum:]][-_[:alnum:]\\.]+)(=(.*))?|-([[:alnum:]].*)"; +CXXOPTS_LINKONCE +const char* const option_specifier_pattern = + "([[:alnum:]][-_[:alnum:]\\.]*)(,[ ]*[[:alnum:]][-_[:alnum:]]*)*"; +CXXOPTS_LINKONCE +const char* const option_specifier_separator_pattern = ", *"; + +} // namespace + +inline IntegerDesc SplitInteger(const std::string &text) +{ + static const std::basic_regex integer_matcher(integer_pattern); - } // namespace + std::smatch match; + std::regex_match(text, match, integer_matcher); - inline IntegerDesc SplitInteger(const std::string &text) - { - std::smatch match; - std::regex_match(text, match, integer_pattern); + if (match.length() == 0) + { + throw_or_mimic(text); + } - if (match.length() == 0) - { - throw_or_mimic(text); - } + IntegerDesc desc; + desc.negative = match[1]; + desc.base = match[2]; + desc.value = match[3]; - IntegerDesc desc; - desc.negative = match[1]; - desc.base = match[2]; - desc.value = match[3]; + if (match.length(4) > 0) + { + desc.base = match[5]; + desc.value = "0"; + return desc; + } - if (match.length(4) > 0) - { - desc.base = match[5]; - desc.value = "0"; - return desc; - } + return desc; +} - return desc; - } +inline bool IsTrueText(const std::string &text) +{ + static const std::basic_regex truthy_matcher(truthy_pattern); + std::smatch result; + std::regex_match(text, result, truthy_matcher); + return !result.empty(); +} - inline bool IsTrueText(const std::string &text) - { - std::smatch result; - std::regex_match(text, result, truthy_pattern); - return !result.empty(); - } +inline bool IsFalseText(const std::string &text) +{ + static const std::basic_regex falsy_matcher(falsy_pattern); + std::smatch result; + std::regex_match(text, result, falsy_matcher); + return !result.empty(); +} - inline bool IsFalseText(const std::string &text) - { - std::smatch result; - std::regex_match(text, result, falsy_pattern); - return !result.empty(); - } +// Gets the option names specified via a single, comma-separated string, +// and returns the separate, space-discarded, non-empty names +// (without considering which or how many are single-character) +inline OptionNames split_option_names(const std::string &text) +{ + static const std::basic_regex option_specifier_matcher(option_specifier_pattern); + if (!std::regex_match(text.c_str(), option_specifier_matcher)) + { + throw_or_mimic(text); + } - inline std::pair SplitSwitchDef(const std::string &text) - { - std::match_results result; - std::regex_match(text.c_str(), result, option_specifier); - if (result.empty()) - { - throw_or_mimic(text); - } + OptionNames split_names; - const std::string& short_sw = result[2]; - const std::string& long_sw = result[3]; + static const std::basic_regex option_specifier_separator_matcher(option_specifier_separator_pattern); + constexpr int use_non_matches { -1 }; + auto token_iterator = std::sregex_token_iterator( + text.begin(), text.end(), option_specifier_separator_matcher, use_non_matches); + std::copy(token_iterator, std::sregex_token_iterator(), std::back_inserter(split_names)); + return split_names; +} - return std::pair(short_sw, long_sw); - } +inline ArguDesc ParseArgument(const char *arg, bool &matched) +{ + static const std::basic_regex option_matcher(option_pattern); + std::match_results result; + std::regex_match(arg, result, option_matcher); + matched = !result.empty(); - inline ArguDesc ParseArgument(const char *arg, bool &matched) - { - std::match_results result; - std::regex_match(arg, result, option_matcher); - matched = !result.empty(); - - ArguDesc argu_desc; - if (matched) { - argu_desc.arg_name = result[1].str(); - argu_desc.set_value = result[2].length() > 0; - argu_desc.value = result[3].str(); - if (result[4].length() > 0) - { - argu_desc.grouping = true; - argu_desc.arg_name = result[4].str(); - } - } + ArguDesc argu_desc; + if (matched) { + argu_desc.arg_name = result[1].str(); + argu_desc.set_value = result[2].length() > 0; + argu_desc.value = result[3].str(); + if (result[4].length() > 0) + { + argu_desc.grouping = true; + argu_desc.arg_name = result[4].str(); + } + } - return argu_desc; - } + return argu_desc; +} #endif // CXXOPTS_NO_REGEX #undef CXXOPTS_NO_REGEX - } +} // namespace parser_tool - namespace detail - { - template - struct SignedCheck; +namespace detail { - template - struct SignedCheck - { - template - void - operator()(bool negative, U u, const std::string& text) - { - if (negative) - { - if (u > static_cast((std::numeric_limits::min)())) - { - throw_or_mimic(text); - } - } - else - { - if (u > static_cast((std::numeric_limits::max)())) - { - throw_or_mimic(text); - } - } - } - }; +template +struct SignedCheck; - template - struct SignedCheck - { - template - void - operator()(bool, U, const std::string&) const {} - }; - - template - void - check_signed_range(bool negative, U value, const std::string& text) +template +struct SignedCheck +{ + template + void + operator()(bool negative, U u, const std::string& text) + { + if (negative) + { + if (u > static_cast((std::numeric_limits::min)())) { - SignedCheck::is_signed>()(negative, value, text); + throw_or_mimic(text); } - } // namespace detail - - template - void - checked_negate(R& r, T&& t, const std::string&, std::true_type) - { - // if we got to here, then `t` is a positive number that fits into - // `R`. So to avoid MSVC C4146, we first cast it to `R`. - // See https://github.com/jarro2783/cxxopts/issues/62 for more details. - r = static_cast(-static_cast(t-1)-1); } - - template - void - checked_negate(R&, T&&, const std::string& text, std::false_type) + else { - throw_or_mimic(text); + if (u > static_cast((std::numeric_limits::max)())) + { + throw_or_mimic(text); + } } + } +}; - template - void - integer_parser(const std::string& text, T& value) - { - parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text); +template +struct SignedCheck +{ + template + void + operator()(bool, U, const std::string&) const {} +}; - using US = typename std::make_unsigned::type; - constexpr bool is_signed = std::numeric_limits::is_signed; +template +void +check_signed_range(bool negative, U value, const std::string& text) +{ + SignedCheck::is_signed>()(negative, value, text); +} - const bool negative = int_desc.negative.length() > 0; - const uint8_t base = int_desc.base.length() > 0 ? 16 : 10; - const std::string & value_match = int_desc.value; +} // namespace detail - US result = 0; +template +void +checked_negate(R& r, T&& t, const std::string&, std::true_type) +{ + // if we got to here, then `t` is a positive number that fits into + // `R`. So to avoid MSVC C4146, we first cast it to `R`. + // See https://github.com/jarro2783/cxxopts/issues/62 for more details. + r = static_cast(-static_cast(t-1)-1); +} - for (char ch : value_match) - { - US digit = 0; +template +void +checked_negate(R&, T&&, const std::string& text, std::false_type) +{ + throw_or_mimic(text); +} - if (ch >= '0' && ch <= '9') - { - digit = static_cast(ch - '0'); - } - else if (base == 16 && ch >= 'a' && ch <= 'f') - { - digit = static_cast(ch - 'a' + 10); - } - else if (base == 16 && ch >= 'A' && ch <= 'F') - { - digit = static_cast(ch - 'A' + 10); - } - else - { - throw_or_mimic(text); - } +template +void +integer_parser(const std::string& text, T& value) +{ + parser_tool::IntegerDesc int_desc = parser_tool::SplitInteger(text); - const US next = static_cast(result * base + digit); - if (result > next) - { - throw_or_mimic(text); - } + using US = typename std::make_unsigned::type; + constexpr bool is_signed = std::numeric_limits::is_signed; - result = next; - } + const bool negative = int_desc.negative.length() > 0; + const uint8_t base = int_desc.base.length() > 0 ? 16 : 10; + const std::string & value_match = int_desc.value; - detail::check_signed_range(negative, result, text); + US result = 0; - if (negative) - { - checked_negate(value, result, text, std::integral_constant()); - } - else - { - value = static_cast(result); - } - } + for (char ch : value_match) + { + US digit = 0; - template - void stringstream_parser(const std::string& text, T& value) + if (ch >= '0' && ch <= '9') { - std::stringstream in(text); - in >> value; - if (!in) { - throw_or_mimic(text); - } + digit = static_cast(ch - '0'); } - - template ::value>::type* = nullptr - > - void parse_value(const std::string& text, T& value) + else if (base == 16 && ch >= 'a' && ch <= 'f') { - integer_parser(text, value); + digit = static_cast(ch - 'a' + 10); } - - inline - void - parse_value(const std::string& text, bool& value) + else if (base == 16 && ch >= 'A' && ch <= 'F') { - if (parser_tool::IsTrueText(text)) - { - value = true; - return; - } - - if (parser_tool::IsFalseText(text)) - { - value = false; - return; - } - - throw_or_mimic(text); + digit = static_cast(ch - 'A' + 10); } - - inline - void - parse_value(const std::string& text, std::string& value) + else { - value = text; + throw_or_mimic(text); } - // The fallback parser. It uses the stringstream parser to parse all types - // that have not been overloaded explicitly. It has to be placed in the - // source code before all other more specialized templates. - template ::value>::type* = nullptr - > - void - parse_value(const std::string& text, T& value) { - stringstream_parser(text, value); + US limit = 0; + if (negative) + { + limit = static_cast(std::abs(static_cast((std::numeric_limits::min)()))); } - - template - void - parse_value(const std::string& text, std::vector& value) + else { - if (text.empty()) { - T v; - parse_value(text, v); - value.emplace_back(std::move(v)); - return; - } - std::stringstream in(text); - std::string token; - while(!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) { - T v; - parse_value(token, v); - value.emplace_back(std::move(v)); - } + limit = (std::numeric_limits::max)(); } -#ifdef CXXOPTS_HAS_OPTIONAL - template - void - parse_value(const std::string& text, std::optional& value) + if (base != 0 && result > limit / base) + { + throw_or_mimic(text); + } + if (result * base > limit - digit) { - T result; - parse_value(text, result); - value = std::move(result); + throw_or_mimic(text); } + + result = static_cast(result * base + digit); + } + + detail::check_signed_range(negative, result, text); + + if (negative) + { + checked_negate(value, result, text, std::integral_constant()); + } + else + { + value = static_cast(result); + } +} + +template +void stringstream_parser(const std::string& text, T& value) +{ + std::stringstream in(text); + in >> value; + if (!in) { + throw_or_mimic(text); + } +} + +template ::value>::type* = nullptr + > +void parse_value(const std::string& text, T& value) +{ + integer_parser(text, value); +} + +inline +void +parse_value(const std::string& text, bool& value) +{ + if (parser_tool::IsTrueText(text)) + { + value = true; + return; + } + + if (parser_tool::IsFalseText(text)) + { + value = false; + return; + } + + throw_or_mimic(text); +} + +inline +void +parse_value(const std::string& text, std::string& value) +{ + value = text; +} + +// The fallback parser. It uses the stringstream parser to parse all types +// that have not been overloaded explicitly. It has to be placed in the +// source code before all other more specialized templates. +template ::value>::type* = nullptr + > +void +parse_value(const std::string& text, T& value) { + stringstream_parser(text, value); +} + +#ifdef CXXOPTS_HAS_OPTIONAL +template +void +parse_value(const std::string& text, std::optional& value) +{ + T result; + parse_value(text, result); + value = std::move(result); +} #endif - inline - void parse_value(const std::string& text, char& c) - { - if (text.length() != 1) - { - throw_or_mimic(text); - } +#ifdef CXXOPTS_HAS_FILESYSTEM +inline +void +parse_value(const std::string& text, std::filesystem::path& value) +{ + value.assign(text); +} +#endif - c = text[0]; - } +inline +void parse_value(const std::string& text, char& c) +{ + if (text.length() != 1) + { + throw_or_mimic(text); + } - template - struct type_is_container - { - static constexpr bool value = false; - }; + c = text[0]; +} + +template +void +parse_value(const std::string& text, std::vector& value) +{ + if (text.empty()) { + T v; + parse_value(text, v); + value.emplace_back(std::move(v)); + return; + } + std::stringstream in(text); + std::string token; + while(!in.eof() && std::getline(in, token, CXXOPTS_VECTOR_DELIMITER)) { + T v; + parse_value(token, v); + value.emplace_back(std::move(v)); + } +} + +template +void +add_value(const std::string& text, T& value) +{ + parse_value(text, value); +} + +template +void +add_value(const std::string& text, std::vector& value) +{ + T v; + add_value(text, v); + value.emplace_back(std::move(v)); +} + +template +struct type_is_container +{ + static constexpr bool value = false; +}; + +template +struct type_is_container> +{ + static constexpr bool value = true; +}; + +template +class abstract_value : public Value +{ + using Self = abstract_value; + + public: + abstract_value() + : m_result(std::make_shared()) + , m_store(m_result.get()) + { + } + + explicit abstract_value(T* t) + : m_store(t) + { + } - template - struct type_is_container> + ~abstract_value() override = default; + + abstract_value& operator=(const abstract_value&) = default; + + abstract_value(const abstract_value& rhs) + { + if (rhs.m_result) { - static constexpr bool value = true; - }; + m_result = std::make_shared(); + m_store = m_result.get(); + } + else + { + m_store = rhs.m_store; + } + + m_default = rhs.m_default; + m_implicit = rhs.m_implicit; + m_default_value = rhs.m_default_value; + m_implicit_value = rhs.m_implicit_value; + } + + void + add(const std::string& text) const override + { + add_value(text, *m_store); + } + + void + parse(const std::string& text) const override + { + parse_value(text, *m_store); + } + + bool + is_container() const override + { + return type_is_container::value; + } + + void + parse() const override + { + parse_value(m_default_value, *m_store); + } + + bool + has_default() const override + { + return m_default; + } - template - class abstract_value : public Value + bool + has_implicit() const override + { + return m_implicit; + } + + std::shared_ptr + default_value(const std::string& value) override + { + m_default = true; + m_default_value = value; + return shared_from_this(); + } + + std::shared_ptr + implicit_value(const std::string& value) override + { + m_implicit = true; + m_implicit_value = value; + return shared_from_this(); + } + + std::shared_ptr + no_implicit_value() override + { + m_implicit = false; + return shared_from_this(); + } + + std::string + get_default_value() const override + { + return m_default_value; + } + + std::string + get_implicit_value() const override + { + return m_implicit_value; + } + + bool + is_boolean() const override + { + return std::is_same::value; + } + + const T& + get() const + { + if (m_store == nullptr) { - using Self = abstract_value; + return *m_result; + } + return *m_store; + } - public: - abstract_value() - : m_result(std::make_shared()) - , m_store(m_result.get()) - { - } + protected: + std::shared_ptr m_result{}; + T* m_store{}; - explicit abstract_value(T* t) - : m_store(t) - { - } + bool m_default = false; + bool m_implicit = false; - ~abstract_value() override = default; + std::string m_default_value{}; + std::string m_implicit_value{}; +}; - abstract_value& operator=(const abstract_value&) = default; +template +class standard_value : public abstract_value +{ + public: + using abstract_value::abstract_value; - abstract_value(const abstract_value& rhs) - { - if (rhs.m_result) - { - m_result = std::make_shared(); - m_store = m_result.get(); - } - else - { - m_store = rhs.m_store; - } + CXXOPTS_NODISCARD + std::shared_ptr + clone() const override + { + return std::make_shared>(*this); + } +}; - m_default = rhs.m_default; - m_implicit = rhs.m_implicit; - m_default_value = rhs.m_default_value; - m_implicit_value = rhs.m_implicit_value; - } +template <> +class standard_value : public abstract_value +{ + public: + ~standard_value() override = default; - void - parse(const std::string& text) const override - { - parse_value(text, *m_store); - } + standard_value() + { + set_default_and_implicit(); + } + + explicit standard_value(bool* b) + : abstract_value(b) + { + m_implicit = true; + m_implicit_value = "true"; + } - bool - is_container() const override - { - return type_is_container::value; - } + std::shared_ptr + clone() const override + { + return std::make_shared>(*this); + } - void - parse() const override - { - parse_value(m_default_value, *m_store); - } + private: - bool - has_default() const override - { - return m_default; - } + void + set_default_and_implicit() + { + m_default = true; + m_default_value = "false"; + m_implicit = true; + m_implicit_value = "true"; + } +}; - bool - has_implicit() const override - { - return m_implicit; - } +} // namespace values - std::shared_ptr - default_value(const std::string& value) override - { - m_default = true; - m_default_value = value; - return shared_from_this(); - } +template +std::shared_ptr +value() +{ + return std::make_shared>(); +} - std::shared_ptr - implicit_value(const std::string& value) override - { - m_implicit = true; - m_implicit_value = value; - return shared_from_this(); - } +template +std::shared_ptr +value(T& t) +{ + return std::make_shared>(&t); +} - std::shared_ptr - no_implicit_value() override - { - m_implicit = false; - return shared_from_this(); - } +class OptionAdder; - std::string - get_default_value() const override - { - return m_default_value; - } +CXXOPTS_NODISCARD +inline +const std::string& +first_or_empty(const OptionNames& long_names) +{ + static const std::string empty{""}; + return long_names.empty() ? empty : long_names.front(); +} - std::string - get_implicit_value() const override - { - return m_implicit_value; - } +class OptionDetails +{ + public: + OptionDetails + ( + std::string short_, + OptionNames long_, + String desc, + std::shared_ptr val + ) + : m_short(std::move(short_)) + , m_long(std::move(long_)) + , m_desc(std::move(desc)) + , m_value(std::move(val)) + , m_count(0) + { + m_hash = std::hash{}(first_long_name() + m_short); + } - bool - is_boolean() const override - { - return std::is_same::value; - } + OptionDetails(const OptionDetails& rhs) + : m_desc(rhs.m_desc) + , m_value(rhs.m_value->clone()) + , m_count(rhs.m_count) + { + } - const T& - get() const - { - if (m_store == nullptr) - { - return *m_result; - } - return *m_store; - } + OptionDetails(OptionDetails&& rhs) = default; - protected: - std::shared_ptr m_result{}; - T* m_store{}; + CXXOPTS_NODISCARD + const String& + description() const + { + return m_desc; + } - bool m_default = false; - bool m_implicit = false; + CXXOPTS_NODISCARD + const Value& + value() const { + return *m_value; + } - std::string m_default_value{}; - std::string m_implicit_value{}; - }; + CXXOPTS_NODISCARD + std::shared_ptr + make_storage() const + { + return m_value->clone(); + } - template - class standard_value : public abstract_value - { - public: - using abstract_value::abstract_value; + CXXOPTS_NODISCARD + const std::string& + short_name() const + { + return m_short; + } - CXXOPTS_NODISCARD - std::shared_ptr - clone() const override - { - return std::make_shared>(*this); - } - }; + CXXOPTS_NODISCARD + const std::string& + first_long_name() const + { + return first_or_empty(m_long); + } - template <> - class standard_value : public abstract_value - { - public: - ~standard_value() override = default; + CXXOPTS_NODISCARD + const std::string& + essential_name() const + { + return m_long.empty() ? m_short : m_long.front(); + } - standard_value() - { - set_default_and_implicit(); - } + CXXOPTS_NODISCARD + const OptionNames & + long_names() const + { + return m_long; + } - explicit standard_value(bool* b) - : abstract_value(b) - { - set_default_and_implicit(); - } + std::size_t + hash() const + { + return m_hash; + } - std::shared_ptr - clone() const override - { - return std::make_shared>(*this); - } + private: + std::string m_short{}; + OptionNames m_long{}; + String m_desc{}; + std::shared_ptr m_value{}; + int m_count; - private: + std::size_t m_hash{}; +}; - void - set_default_and_implicit() - { - m_default = true; - m_default_value = "false"; - m_implicit = true; - m_implicit_value = "true"; - } - }; - } // namespace values +struct HelpOptionDetails +{ + std::string s; + OptionNames l; + String desc; + bool has_default; + std::string default_value; + bool has_implicit; + std::string implicit_value; + std::string arg_help; + bool is_container; + bool is_boolean; +}; + +struct HelpGroupDetails +{ + std::string name{}; + std::string description{}; + std::vector options{}; +}; - template - std::shared_ptr - value() +class OptionValue +{ + public: + void + add + ( + const std::shared_ptr& details, + const std::string& text + ) { - return std::make_shared>(); + ensure_value(details); + ++m_count; + m_value->add(text); + m_long_names = &details->long_names(); } - template - std::shared_ptr - value(T& t) + void + parse + ( + const std::shared_ptr& details, + const std::string& text + ) { - return std::make_shared>(&t); + ensure_value(details); + ++m_count; + m_value->parse(text); + m_long_names = &details->long_names(); } - class OptionAdder; + void + parse_default(const std::shared_ptr& details) + { + ensure_value(details); + m_default = true; + m_long_names = &details->long_names(); + m_value->parse(); + } - class OptionDetails + void + parse_no_value(const std::shared_ptr& details) { - public: - OptionDetails - ( - std::string short_, - std::string long_, - String desc, - std::shared_ptr val - ) - : m_short(std::move(short_)) - , m_long(std::move(long_)) - , m_desc(std::move(desc)) - , m_value(std::move(val)) - , m_count(0) - { - m_hash = std::hash{}(m_long + m_short); - } + m_long_names = &details->long_names(); + } - OptionDetails(const OptionDetails& rhs) - : m_desc(rhs.m_desc) - , m_value(rhs.m_value->clone()) - , m_count(rhs.m_count) - { - } +#if defined(CXXOPTS_NULL_DEREF_IGNORE) +CXXOPTS_DIAGNOSTIC_PUSH +CXXOPTS_IGNORE_WARNING("-Wnull-dereference") +#endif - OptionDetails(OptionDetails&& rhs) = default; + CXXOPTS_NODISCARD + std::size_t + count() const noexcept + { + return m_count; + } - CXXOPTS_NODISCARD - const String& - description() const - { - return m_desc; - } +#if defined(CXXOPTS_NULL_DEREF_IGNORE) +CXXOPTS_DIAGNOSTIC_POP +#endif - CXXOPTS_NODISCARD - const Value& - value() const { - return *m_value; - } + // TODO: maybe default options should count towards the number of arguments + CXXOPTS_NODISCARD + bool + has_default() const noexcept + { + return m_default; + } - CXXOPTS_NODISCARD - std::shared_ptr - make_storage() const - { - return m_value->clone(); + template + const T& + as() const + { + if (m_value == nullptr) { + throw_or_mimic( + m_long_names == nullptr ? "" : first_or_empty(*m_long_names)); } - CXXOPTS_NODISCARD - const std::string& - short_name() const - { - return m_short; - } + return CXXOPTS_RTTI_CAST&>(*m_value).get(); + } - CXXOPTS_NODISCARD - const std::string& - long_name() const - { - return m_long; +#ifdef CXXOPTS_HAS_OPTIONAL + template + std::optional + as_optional() const + { + if (m_value == nullptr) { + return std::nullopt; } + return as(); + } +#endif - size_t - hash() const + private: + void + ensure_value(const std::shared_ptr& details) + { + if (m_value == nullptr) { - return m_hash; + m_value = details->make_storage(); } + } - private: - std::string m_short{}; - std::string m_long{}; - String m_desc{}; - std::shared_ptr m_value{}; - int m_count; - - size_t m_hash{}; - }; - struct HelpOptionDetails - { - std::string s; - std::string l; - String desc; - bool has_default; - std::string default_value; - bool has_implicit; - std::string implicit_value; - std::string arg_help; - bool is_container; - bool is_boolean; - }; + const OptionNames * m_long_names = nullptr; + // Holding this pointer is safe, since OptionValue's only exist in key-value pairs, + // where the key has the string we point to. + std::shared_ptr m_value{}; + std::size_t m_count = 0; + bool m_default = false; +}; - struct HelpGroupDetails +class KeyValue +{ + public: + KeyValue(std::string key_, std::string value_) noexcept + : m_key(std::move(key_)) + , m_value(std::move(value_)) { - std::string name{}; - std::string description{}; - std::vector options{}; - }; + } - class OptionValue + CXXOPTS_NODISCARD + const std::string& + key() const { - public: - void - parse - ( - const std::shared_ptr& details, - const std::string& text - ) - { - ensure_value(details); - ++m_count; - m_value->parse(text); - m_long_name = &details->long_name(); - } + return m_key; + } - void - parse_default(const std::shared_ptr& details) - { - ensure_value(details); - m_default = true; - m_long_name = &details->long_name(); - m_value->parse(); - } + CXXOPTS_NODISCARD + const std::string& + value() const + { + return m_value; + } - void - parse_no_value(const std::shared_ptr& details) - { - m_long_name = &details->long_name(); - } + template + T + as() const + { + T result; + values::parse_value(m_value, result); + return result; + } -#if defined(CXXOPTS_NULL_DEREF_IGNORE) -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wnull-dereference" -#endif + private: + std::string m_key; + std::string m_value; +}; - CXXOPTS_NODISCARD - size_t - count() const noexcept - { - return m_count; - } +using ParsedHashMap = std::unordered_map; +using NameHashMap = std::unordered_map; -#if defined(CXXOPTS_NULL_DEREF_IGNORE) -#pragma GCC diagnostic pop -#endif +class ParseResult +{ + public: + class Iterator + { + public: + using iterator_category = std::forward_iterator_tag; + using value_type = KeyValue; + using difference_type = void; + using pointer = const KeyValue*; + using reference = const KeyValue&; - // TODO: maybe default options should count towards the number of arguments - CXXOPTS_NODISCARD - bool - has_default() const noexcept - { - return m_default; - } + Iterator() = default; + Iterator(const Iterator&) = default; - template - const T& - as() const +// GCC complains about m_iter not being initialised in the member +// initializer list +CXXOPTS_DIAGNOSTIC_PUSH +CXXOPTS_IGNORE_WARNING("-Weffc++") + Iterator(const ParseResult *pr, bool end=false) + : m_pr(pr) { - if (m_value == nullptr) { - throw_or_mimic( - m_long_name == nullptr ? "" : *m_long_name); + if (end) + { + m_sequential = false; + m_iter = m_pr->m_defaults.end(); } + else + { + m_sequential = true; + m_iter = m_pr->m_sequential.begin(); -#ifdef CXXOPTS_NO_RTTI - return static_cast&>(*m_value).get(); -#else - return dynamic_cast&>(*m_value).get(); -#endif + if (m_iter == m_pr->m_sequential.end()) + { + m_sequential = false; + m_iter = m_pr->m_defaults.begin(); + } + } } +CXXOPTS_DIAGNOSTIC_POP - private: - void - ensure_value(const std::shared_ptr& details) + Iterator& operator++() { - if (m_value == nullptr) + ++m_iter; + if(m_sequential && m_iter == m_pr->m_sequential.end()) { - m_value = details->make_storage(); + m_sequential = false; + m_iter = m_pr->m_defaults.begin(); + return *this; } + return *this; } + Iterator operator++(int) + { + Iterator retval = *this; + ++(*this); + return retval; + } - const std::string* m_long_name = nullptr; - // Holding this pointer is safe, since OptionValue's only exist in key-value pairs, - // where the key has the string we point to. - std::shared_ptr m_value{}; - size_t m_count = 0; - bool m_default = false; - }; - - class KeyValue - { - public: - KeyValue(std::string key_, std::string value_) - : m_key(std::move(key_)) - , m_value(std::move(value_)) + bool operator==(const Iterator& other) const { + return (m_sequential == other.m_sequential) && (m_iter == other.m_iter); } - CXXOPTS_NODISCARD - const std::string& - key() const + bool operator!=(const Iterator& other) const { - return m_key; + return !(*this == other); } - CXXOPTS_NODISCARD - const std::string& - value() const + const KeyValue& operator*() { - return m_value; + return *m_iter; } - template - T - as() const + const KeyValue* operator->() { - T result; - values::parse_value(m_value, result); - return result; + return m_iter.operator->(); } private: - std::string m_key; - std::string m_value; + const ParseResult* m_pr; + std::vector::const_iterator m_iter; + bool m_sequential = true; }; - using ParsedHashMap = std::unordered_map; - using NameHashMap = std::unordered_map; + ParseResult() = default; + ParseResult(const ParseResult&) = default; - class ParseResult + ParseResult(NameHashMap&& keys, ParsedHashMap&& values, std::vector sequential, + std::vector default_opts, std::vector&& unmatched_args) + : m_keys(std::move(keys)) + , m_values(std::move(values)) + , m_sequential(std::move(sequential)) + , m_defaults(std::move(default_opts)) + , m_unmatched(std::move(unmatched_args)) { - public: - class Iterator - { - public: - using iterator_category = std::forward_iterator_tag; - using value_type = KeyValue; - using difference_type = void; - using pointer = const KeyValue*; - using reference = const KeyValue&; - - Iterator() = default; - Iterator(const Iterator&) = default; - - Iterator(const ParseResult *pr, bool end=false) - : m_pr(pr) - , m_iter(end? pr->m_defaults.end(): pr->m_sequential.begin()) - { - } - - Iterator& operator++() - { - ++m_iter; - if(m_iter == m_pr->m_sequential.end()) - { - m_iter = m_pr->m_defaults.begin(); - return *this; - } - return *this; - } + } - Iterator operator++(int) - { - Iterator retval = *this; - ++(*this); - return retval; - } + ParseResult& operator=(ParseResult&&) = default; + ParseResult& operator=(const ParseResult&) = default; - bool operator==(const Iterator& other) const - { - return m_iter == other.m_iter; - } + Iterator + begin() const + { + return Iterator(this); + } - bool operator!=(const Iterator& other) const - { - return !(*this == other); - } + Iterator + end() const + { + return Iterator(this, true); + } - const KeyValue& operator*() - { - return *m_iter; - } + std::size_t + count(const std::string& o) const + { + auto iter = m_keys.find(o); + if (iter == m_keys.end()) + { + return 0; + } - const KeyValue* operator->() - { - return m_iter.operator->(); - } + auto viter = m_values.find(iter->second); - private: - const ParseResult* m_pr; - std::vector::const_iterator m_iter; - }; - - ParseResult() = default; - ParseResult(const ParseResult&) = default; - - ParseResult(NameHashMap&& keys, ParsedHashMap&& values, std::vector sequential, - std::vector default_opts, std::vector&& unmatched_args) - : m_keys(std::move(keys)) - , m_values(std::move(values)) - , m_sequential(std::move(sequential)) - , m_defaults(std::move(default_opts)) - , m_unmatched(std::move(unmatched_args)) + if (viter == m_values.end()) { + return 0; } - ParseResult& operator=(ParseResult&&) = default; - ParseResult& operator=(const ParseResult&) = default; + return viter->second.count(); + } + + bool + contains(const std::string& o) const + { + return static_cast(count(o)); + } + + const OptionValue& + operator[](const std::string& option) const + { + auto iter = m_keys.find(option); - Iterator - begin() const + if (iter == m_keys.end()) { - return Iterator(this); + throw_or_mimic(option); } - Iterator - end() const + auto viter = m_values.find(iter->second); + + if (viter == m_values.end()) { - return Iterator(this, true); + throw_or_mimic(option); } - size_t - count(const std::string& o) const + return viter->second; + } + +#ifdef CXXOPTS_HAS_OPTIONAL + template + std::optional + as_optional(const std::string& option) const + { + auto iter = m_keys.find(option); + if (iter != m_keys.end()) { - auto iter = m_keys.find(o); - if (iter == m_keys.end()) + auto viter = m_values.find(iter->second); + if (viter != m_values.end()) { - return 0; + return viter->second.as_optional(); } + } + return std::nullopt; + } +#endif - auto viter = m_values.find(iter->second); + const std::vector& + arguments() const + { + return m_sequential; + } - if (viter == m_values.end()) - { - return 0; - } + const std::vector& + unmatched() const + { + return m_unmatched; + } - return viter->second.count(); - } + const std::vector& + defaults() const + { + return m_defaults; + } - const OptionValue& - operator[](const std::string& option) const + const std::string + arguments_string() const + { + std::string result; + for(const auto& kv: m_sequential) + { + result += kv.key() + " = " + kv.value() + "\n"; + } + for(const auto& kv: m_defaults) { - auto iter = m_keys.find(option); + result += kv.key() + " = " + kv.value() + " " + "(default)" + "\n"; + } + return result; + } - if (iter == m_keys.end()) - { - throw_or_mimic(option); - } + private: + NameHashMap m_keys{}; + ParsedHashMap m_values{}; + std::vector m_sequential{}; + std::vector m_defaults{}; + std::vector m_unmatched{}; +}; - auto viter = m_values.find(iter->second); +struct Option +{ + Option + ( + std::string opts, + std::string desc, + std::shared_ptr value = ::cxxopts::value(), + std::string arg_help = "" + ) + : opts_(std::move(opts)) + , desc_(std::move(desc)) + , value_(std::move(value)) + , arg_help_(std::move(arg_help)) + { + } - if (viter == m_values.end()) - { - throw_or_mimic(option); - } + std::string opts_; + std::string desc_; + std::shared_ptr value_; + std::string arg_help_; +}; + +using OptionMap = std::unordered_map>; +using PositionalList = std::vector; +using PositionalListIterator = PositionalList::const_iterator; + +class OptionParser +{ + public: + OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised) + : m_options(options) + , m_positional(positional) + , m_allow_unrecognised(allow_unrecognised) + { + } + + ParseResult + parse(int argc, const char* const* argv); + + bool + consume_positional(const std::string& a, PositionalListIterator& next); + + void + checked_parse_arg + ( + int argc, + const char* const* argv, + int& current, + const std::shared_ptr& value, + const std::string& name + ); - return viter->second; - } + void + add_to_option(const std::shared_ptr& value, const std::string& arg); - const std::vector& - arguments() const - { - return m_sequential; - } + void + parse_option + ( + const std::shared_ptr& value, + const std::string& name, + const std::string& arg = "" + ); - const std::vector& - unmatched() const - { - return m_unmatched; - } + void + parse_default(const std::shared_ptr& details); - const std::vector& - defaults() const - { - return m_defaults; - } + void + parse_no_value(const std::shared_ptr& details); - const std::string - arguments_string() const - { - std::string result; - for(const auto& kv: m_sequential) - { - result += kv.key() + " = " + kv.value() + "\n"; - } - for(const auto& kv: m_defaults) - { - result += kv.key() + " = " + kv.value() + " " + "(default)" + "\n"; - } - return result; - } + private: - private: - NameHashMap m_keys{}; - ParsedHashMap m_values{}; - std::vector m_sequential{}; - std::vector m_defaults{}; - std::vector m_unmatched{}; - }; + void finalise_aliases(); - struct Option - { - Option - ( - std::string opts, - std::string desc, - std::shared_ptr value = ::cxxopts::value(), - std::string arg_help = "" - ) - : opts_(std::move(opts)) - , desc_(std::move(desc)) - , value_(std::move(value)) - , arg_help_(std::move(arg_help)) - { - } + const OptionMap& m_options; + const PositionalList& m_positional; - std::string opts_; - std::string desc_; - std::shared_ptr value_; - std::string arg_help_; - }; + std::vector m_sequential{}; + std::vector m_defaults{}; + bool m_allow_unrecognised; - using OptionMap = std::unordered_map>; - using PositionalList = std::vector; - using PositionalListIterator = PositionalList::const_iterator; + ParsedHashMap m_parsed{}; + NameHashMap m_keys{}; +}; - class OptionParser +class Options +{ + public: + + explicit Options(std::string program_name, std::string help_string = "") + : m_program(std::move(program_name)) + , m_help_string(toLocalString(std::move(help_string))) + , m_custom_help("[OPTION...]") + , m_positional_help("positional parameters") + , m_show_positional(false) + , m_allow_unrecognised(false) + , m_width(76) + , m_tab_expansion(false) + , m_options(std::make_shared()) { - public: - OptionParser(const OptionMap& options, const PositionalList& positional, bool allow_unrecognised) - : m_options(options) - , m_positional(positional) - , m_allow_unrecognised(allow_unrecognised) - { - } - - ParseResult - parse(int argc, const char* const* argv); + } - bool - consume_positional(const std::string& a, PositionalListIterator& next); + Options& + positional_help(std::string help_text) + { + m_positional_help = std::move(help_text); + return *this; + } - void - checked_parse_arg - ( - int argc, - const char* const* argv, - int& current, - const std::shared_ptr& value, - const std::string& name - ); + Options& + custom_help(std::string help_text) + { + m_custom_help = std::move(help_text); + return *this; + } - void - add_to_option(OptionMap::const_iterator iter, const std::string& option, const std::string& arg); + Options& + show_positional_help() + { + m_show_positional = true; + return *this; + } - void - parse_option - ( - const std::shared_ptr& value, - const std::string& name, - const std::string& arg = "" - ); + Options& + allow_unrecognised_options() + { + m_allow_unrecognised = true; + return *this; + } - void - parse_default(const std::shared_ptr& details); + Options& + set_width(std::size_t width) + { + m_width = width; + return *this; + } - void - parse_no_value(const std::shared_ptr& details); + Options& + set_tab_expansion(bool expansion=true) + { + m_tab_expansion = expansion; + return *this; + } - private: + ParseResult + parse(int argc, const char* const* argv); - void finalise_aliases(); + OptionAdder + add_options(std::string group = ""); - const OptionMap& m_options; - const PositionalList& m_positional; + void + add_options + ( + const std::string& group, + std::initializer_list