diff --git a/.github/workflows/run_ci_checks.yaml b/.github/workflows/run_ci_checks.yaml new file mode 100644 index 0000000..e4667df --- /dev/null +++ b/.github/workflows/run_ci_checks.yaml @@ -0,0 +1,15 @@ +--- +name: Run CI checks +on: + pull_request: + types: "**" + branches: "**" + pull_request_review: + types: "**" + branches: "**" +permissions: read-all +jobs: + TriggerWorkfows: + uses: projectceladon/celadonworkflows/.github/workflows/trigger_ci.yml@v1.0 + with: + EVENT: ${{ toJSON(github.event) }} diff --git a/Android.bp b/Android.bp new file mode 100644 index 0000000..c573936 --- /dev/null +++ b/Android.bp @@ -0,0 +1,41 @@ +cc_defaults { + name: "OpenCL-ICD-Loader-defaults", + + vendor: true, + + cflags: [ + "-Wno-error", + "-Wno-error=implicit-function-declaration", + "-DAMD64", + ], + + cppflags: [ + "-D__ANDROID__", + ], + + clang_cflags: [ + + ], + + include_dirs: [ + "hardware/intel/external/opencl/compute-runtime/third_party/opencl_headers", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} + + +build = [ + "libOpenCL.bp", + "libIcdLog.bp", + "libOpenCLDriverStub.bp", + "icd_loader_test.bp", + "clinfo.bp", +] diff --git a/CMakeLists.txt b/CMakeLists.txt index 21da30d..7cb3079 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,9 +1,18 @@ -cmake_minimum_required (VERSION 2.8.11) +cmake_minimum_required (VERSION 3.1) + +# Include guard for including this project multiple times +if(TARGET OpenCL) + return() +endif() + +project (OpenCL-ICD-Loader + VERSION 1.2 + LANGUAGES C) -project (OPENCL_ICD_LOADER) -include (GNUInstallDirs) find_package (Threads REQUIRED) +set(CMAKE_C_STANDARD 99) +set(CMAKE_C_STANDARD_REQUIRED ON) # The option below allows building the ICD Loader library as a shared library # (ON, default) or a static library (OFF). # @@ -32,7 +41,22 @@ find_package (Threads REQUIRED) # may be useful to simplify the build and distribution of the application. E.g. # in test farms, or in cases where the end-user system configs are known in # advance. Use it with discretion. -option (BUILD_SHARED_LIBS "Build shared libs" ON) +if(DEFINED BUILD_SHARED_LIBS) + set(OPENCL_ICD_LOADER_BUILD_SHARED_LIBS_DEFAULT ${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}) + +# 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) + +set (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") +include(JoinPaths) include(CheckFunctionExists) check_function_exists(secure_getenv HAVE_SECURE_GETENV) @@ -43,20 +67,25 @@ 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 loader/icd_envvars.h loader/icd_platform.h) if (WIN32) - list (APPEND OPENCL_ICD_LOADER_SOURCES + list (APPEND OPENCL_ICD_LOADER_SOURCES + loader/windows/adapter.h loader/windows/icd_windows.c + loader/windows/icd_windows.h loader/windows/icd_windows_dxgk.c loader/windows/icd_windows_dxgk.h loader/windows/icd_windows_envvars.c loader/windows/icd_windows_hkr.c loader/windows/icd_windows_hkr.h - loader/windows/OpenCL.def + loader/windows/icd_windows_apppackage.c + loader/windows/icd_windows_apppackage.h 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 @@ -64,6 +93,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 @@ -71,67 +108,188 @@ else () loader/linux/icd_exports.map) endif () -set (OPENCL_ICD_LOADER_HEADERS_DIR ${CMAKE_CURRENT_SOURCE_DIR}/inc CACHE PATH "Path to OpenCL Headers") +set (OPENCL_ICD_LOADER_HEADERS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/inc" CACHE PATH "Path to OpenCL Headers") + +if (${OPENCL_ICD_LOADER_BUILD_SHARED_LIBS}) + add_library (OpenCL SHARED ${OPENCL_ICD_LOADER_SOURCES}) +else() + add_library (OpenCL STATIC ${OPENCL_ICD_LOADER_SOURCES}) +endif() + +add_library (OpenCL::OpenCL ALIAS OpenCL) -add_library (OpenCL ${OPENCL_ICD_LOADER_SOURCES}) set_target_properties (OpenCL PROPERTIES VERSION "1.2" SOVERSION "1") if (WIN32) - target_link_libraries (OpenCL cfgmgr32.lib) - - option (OPENCL_ICD_LOADER_REQUIRE_WDK "Build with D3DKMT support, which requires the Windows WDK." ON) - if (OPENCL_ICD_LOADER_REQUIRE_WDK) - if(DEFINED ENV{WDKContentRoot}) - file(GLOB D3DKMT_HEADER "$ENV{WDKContentRoot}/Include/*/km/d3dkmthk.h") - else() - file(GLOB D3DKMT_HEADER "$ENV{HOMEDRIVE}/Program Files */Windows Kits/10/Include/*/km/d3dkmthk.h") - endif() - - if(D3DKMT_HEADER) - list(GET D3DKMT_HEADER -1 LATEST_D3DKMT_HEADER) - get_filename_component(WDK_DIRECTORY ${LATEST_D3DKMT_HEADER} DIRECTORY) - get_filename_component(WDK_DIRECTORY ${WDK_DIRECTORY} DIRECTORY) - message(STATUS "Found the Windows WDK in: ${WDK_DIRECTORY}") - target_compile_definitions(OpenCL PRIVATE OPENCL_ICD_LOADER_REQUIRE_WDK) - target_include_directories(OpenCL PRIVATE ${WDK_DIRECTORY}/um) - target_include_directories(OpenCL PRIVATE ${WDK_DIRECTORY}/km) - target_include_directories(OpenCL PRIVATE ${WDK_DIRECTORY}/shared) - else() - message(FATAL_ERROR "The Windows WDK was not found. Consider disabling OPENCL_ICD_LOADER_REQUIRE_WDK. Aborting.") - endif() - endif() + target_link_libraries (OpenCL PRIVATE cfgmgr32.lib runtimeobject.lib) - if(NOT USE_DYNAMIC_VCXX_RUNTIME) - string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}") - string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}") - string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}") - string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}") - string(REPLACE "/MD" "/MT" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}") - string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}") - string(REPLACE "/MDd" "/MTd" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}") - string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") + # 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() - if (APPLE) - target_link_libraries (OpenCL ${CMAKE_THREAD_LIBS_INIT}) - else () + 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") - target_link_libraries (OpenCL ${CMAKE_THREAD_LIBS_INIT}) + if (OPENCL_ICD_LOADER_PIC) + set_target_properties(OpenCL PROPERTIES POSITION_INDEPENDENT_CODE ON) + endif () endif () endif () -include_directories (${OPENCL_ICD_LOADER_HEADERS_DIR}) -add_definitions (-DCL_TARGET_OPENCL_VERSION=220) +if (EXISTS ${OPENCL_ICD_LOADER_HEADERS_DIR}/CL/cl.h) + message (STATUS "Defining OpenCL::Headers through OPENCL_ICD_LOADER_HEADERS_DIR") + add_library (OpenCLHeaders INTERFACE) + add_library (OpenCL::Headers ALIAS OpenCLHeaders) + target_include_directories (OpenCLHeaders INTERFACE ${OPENCL_ICD_LOADER_HEADERS_DIR}) + target_include_directories (OpenCL PUBLIC $) +else () + if (NOT TARGET OpenCL::Headers) + find_package (OpenCLHeaders REQUIRED) + endif () + target_link_libraries (OpenCL PUBLIC OpenCL::Headers) +endif () + +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> +) + +target_compile_definitions (OpenCL + PRIVATE + ${OPENCL_COMPILE_DEFINITIONS} +) -target_include_directories (OpenCL PRIVATE ${CMAKE_CURRENT_BINARY_DIR} loader) -target_link_libraries (OpenCL ${CMAKE_DL_LIBS}) +target_include_directories (OpenCL + PRIVATE + ${CMAKE_CURRENT_BINARY_DIR} + loader +) +target_link_libraries (OpenCL PUBLIC ${CMAKE_DL_LIBS}) -include (CTest) -if (BUILD_TESTING) +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) + include(CTest) +endif() +if((CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME OR OPENCL_ICD_LOADER_BUILD_TESTING) AND BUILD_TESTING) add_subdirectory (test) endif() +include (GNUInstallDirs) + +install( + TARGETS OpenCL + EXPORT OpenCLICDLoaderTargets + LIBRARY + 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) +# FILES $/OpenCL.pdb looks OK, but even though there's a PDB, this prop is empty on non-MSVC toolchains + FILES $/OpenCL.pdb # is the most implicit (expect PDB be next to the library), yet the only one that universally works + DESTINATION ${CMAKE_INSTALL_BINDIR} + OPTIONAL +) + +if (ENABLE_OPENCL_LAYERINFO) + install( + TARGETS cllayerinfo + EXPORT OpenCLICDLoaderTargets + RUNTIME + DESTINATION ${CMAKE_INSTALL_BINDIR} + ) +endif() + +export( + EXPORT OpenCLICDLoaderTargets + FILE ${PROJECT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderTargets.cmake + NAMESPACE OpenCL:: +) +file( + WRITE ${PROJECT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfig.cmake + "include(\"\${CMAKE_CURRENT_LIST_DIR}/OpenCLICDLoaderTargets.cmake\")" +) + +set(config_package_location ${CMAKE_INSTALL_DATADIR}/cmake/OpenCLICDLoader) +install( + EXPORT OpenCLICDLoaderTargets + FILE OpenCLICDLoaderTargets.cmake + NAMESPACE OpenCL:: + DESTINATION ${config_package_location} +) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfig.cmake + DESTINATION ${config_package_location} +) + +unset(CMAKE_SIZEOF_VOID_P) +include(CMakePackageConfigHelpers) +write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion +) +install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCLICDLoader/OpenCLICDLoaderConfigVersion.cmake + DESTINATION ${config_package_location} +) + install (TARGETS OpenCL RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) + +join_paths(OPENCL_LIBDIR_PC "\${exec_prefix}" "${CMAKE_INSTALL_LIBDIR}") +join_paths(OPENCL_INCLUDEDIR_PC "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + +if (NOT MSVC) + configure_file(OpenCL.pc.in OpenCL.pc @ONLY) + set(pkg_config_location ${CMAKE_INSTALL_LIBDIR}/pkgconfig) + install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/OpenCL.pc + DESTINATION ${pkg_config_location}) +endif() diff --git a/OpenCL.pc.in b/OpenCL.pc.in new file mode 100644 index 0000000..1b6730c --- /dev/null +++ b/OpenCL.pc.in @@ -0,0 +1,9 @@ +prefix=@CMAKE_INSTALL_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/README.md b/README.md index ee8499a..a7aa865 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,12 @@ -# OpenCL ICD Loader +# OpenCLTM ICD Loader This repo contains the source code and tests for the Khronos official OpenCL ICD Loader. ## CI Build Status -[![Windows Build Status](https://ci.appveyor.com/api/projects/status/47uhjgp5h4de2f63/branch/master?svg=true)](https://ci.appveyor.com/project/Khronoswebmaster/opencl-icd-loader/branch/master) [![Linux OSX Build Status](https://travis-ci.com/KhronosGroup/opencl-icd-loader.svg?branch=master)](https://travis-ci.com/KhronosGroup/opencl-icd-loader) +[![Windows Build Status](https://github.com/KhronosGroup/OpenCL-ICD-Loader/workflows/Windows/badge.svg)](https://github.com/KhronosGroup/OpenCL-ICD-Loader/actions?query=workflow%3AWindows) +[![Linux Build Status](https://github.com/KhronosGroup/OpenCL-ICD-Loader/workflows/Linux/badge.svg)](https://github.com/KhronosGroup/OpenCL-ICD-Loader/actions?query=workflow%3ALinux) +[![MacOS Build Status](https://github.com/KhronosGroup/OpenCL-ICD-Loader/workflows/MacOS/badge.svg)](https://github.com/KhronosGroup/OpenCL-ICD-Loader/actions?query=workflow%3AMacOS) ## Introduction @@ -24,71 +26,80 @@ The OpenCL *Installable Client Driver* extension (`cl_khr_icd`) is described in ## Build Instructions -### Dependencies - -The OpenCL ICD Loader requires OpenCL Headers. -To use system OpenCL Headers, please specify the OpenCL Header location using the CMake variable `OPENCL_ICD_LOADER_HEADERS_DIR`. -By default, the OpenCL ICD Loader will look for OpenCL Headers in the `inc` directory. +> While the ICD Loader 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. -By default, the OpenCL ICD Loader on Windows requires the Windows Driver Kit (WDK). -An OpenCL ICD Loader may be built without the Windows Driver Kit using the CMake variable `OPENCL_ICD_LOADER_REQUIRE_WDK`, however this option should be used with caution since it may prevent the OpenCL ICD Loader from enumerating some OpenCL implementations. -This dependency may be removed in the future. +### Dependencies -The OpenCL ICD Loader uses CMake for its build system. +The OpenCL ICD Loader requires: +- 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_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). -### Build and Install Directories - -A common convention is to place the `build` directory in the top directory of the repository and to place the `install` directory as a child of the `build` directory. -The remainder of these instructions follow this convention, although you may place these directories in any location. - -### Example Usage +### Example Build For most Windows and Linux usages, the following steps are sufficient to build the OpenCL ICD Loader: -1. Clone this repo: +1. Clone this repo and the OpenCL Headers: git clone https://github.com/KhronosGroup/OpenCL-ICD-Loader + git clone https://github.com/KhronosGroup/OpenCL-Headers -1. Obtain the OpenCL Headers, if you are not planning to use system OpenCL headers. -Headers may be obtained from the [Khronos OpenCL Headers](https://github.com/KhronosGroup/OpenCL-Headers) repository. +1. Install OpenCL Headers CMake package -1. Create a `build` directory: + cmake -D CMAKE_INSTALL_PREFIX=./OpenCL-Headers/install -S ./OpenCL-Headers -B ./OpenCL-Headers/build + cmake --build ./OpenCL-Headers/build --target install - cd OpenCL-ICD-Loader - mkdir build - cd build +1. Build and install OpenCL ICD Loader CMake package. _(Note that `CMAKE_PREFIX_PATH` need to be an absolute path. Update as needed.)_ -1. Invoke `cmake` to generate solution files, Makefiles, or files for other build systems. + 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 - cmake .. +Notes: -1. Build using the CMake-generated files. +* For x64 Windows builds, you need to instruct the default Visual Studio generator by adding `-A x64` to all your command-lines. -Notes: +* Some users may prefer to use a CMake GUI frontend, such as `cmake-gui` or `ccmake`, vs. the command-line CMake. -* For 64-bit Windows builds, you may need to specify a 64-bit generator manually, for example: +### Example Use - cmake.exe -G "Visual Studio 14 2015 Win64" .. +Example CMake invocation -* Some users may prefer to use a CMake GUI frontend, such as `cmake-gui` or `ccmake`, vs. the command-line CMake. +```bash +cmake -D CMAKE_PREFIX_PATH="/chosen/install/prefix/of/headers;/chosen/install/prefix/of/loader" /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) +target_link_libraries(app PRIVATE OpenCL::Headers OpenCL::OpenCL) +``` ## OpenCL ICD Loader Tests -OpenCL ICD Loader Tests can be run using `ctest`, which is a companion to CMake. -The OpenCL ICD Loader Tests can also be run directly by executing icd_loader_test(.exe) executable from the bin folder. +OpenCL ICD Loader Tests can be run using `ctest` from the `build` directory. CTest which is a companion to CMake. The OpenCL ICD Loader Tests can also be run directly by executing `icd_loader_test[.exe]` executable from the bin folder. + +_(Note that running the tests manually requires setting up it's env manually, by setting `OCL_ICD_FILENAMES` to the full path of `libOpenCLDriverStub.so`/`OpenCLDriverStub.dll`, something otherwise done by CTest.)_ -### Test Setup +## Registering ICDs -The OpenCL ICD Loader Tests use a "stub" ICD, which must be set up manually. -The OpenCL ICD Loader Tests will "fail" if the "stub" ICD is not set up correctly. -The method to install the "stub" ICD is operating system dependent. +The method to installing an ICD is operating system dependent. -On Linux, install the "stub" ICD by creating a file with the full path to the "stub" ICD in `/etc/OpenCL/vendors`: +### Registering an ICD on Linux + +Install your ICD by creating a file with the full path to the library of your implementation in `/etc/OpenCL/vendors` for eg.: echo full/path/to/libOpenCLDriverStub.so > /etc/OpenCL/vendors/test.icd -On Windows, add the "stub" ICD by adding a `REG_DWORD` value to the registry keys: +### Registering an ICD on Windows + +Install your ICD by adding a `REG_DWORD` value to the registry keys: // For 32-bit operating systems, or 64-bit tests on a 64-bit operating system: HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors @@ -96,17 +107,25 @@ On Windows, add the "stub" ICD by adding a `REG_DWORD` value to the registry key // For 32-bit tests on a 64-bit operating system: HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Khronos\OpenCL\Vendors - // The name of the REG_DWORD value should be the full path to the "stub" ICD + // The name of the REG_DWORD value should be the full path to the library of your implementation, for eg. // OpenCLDriverStub.dll, and the data for this value should be 0. -### Running Tests +## About Layers + +Layers have been added as an experimental feature in the OpenCL ICD Loader. We do not +expect the API or ABI to change significantly, but the OpenCL Working Group reserves +the right to do so. The layer support can also be completely deactivated during +configuration by using the `ENABLE_OPENCL_LAYERS` (`ON` by default) cmake variable: -To run the tests, invoke `ctest` from the `build` directory. -The CMake-generated build files may be able to invoke the OpenCL ICD Loader tests as well. +```bash +cmake -DENABLE_OPENCL_LAYERS=OFF +``` -### Test Cleanup +For now, runtime configuration of layers is done using the `OPENCL_LAYERS` environment +variable. A colon (Linux) or semicolon (Windows) list of layers to use can be provided +through this environment variable. -Manually remove the file or registry keys added during Test Setup. +We are looking for feedback. ## Support @@ -125,3 +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` | +| 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/bp/defaults.tpl b/bp/defaults.tpl new file mode 100755 index 0000000..eb5c087 --- /dev/null +++ b/bp/defaults.tpl @@ -0,0 +1,55 @@ +# Copyright(c) 2019 Intel Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files(the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and / or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER 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. +# +cc_defaults { + name: "@name", + + vendor: true, + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + clang_cflags: [ +@clang_cflags + ], + + include_dirs: [ +@include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} + + +build = [ +@build +] diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl new file mode 100755 index 0000000..5c6632e --- /dev/null +++ b/bp/icd-loader.tpl @@ -0,0 +1,55 @@ +# Copyright(c) 2019 Intel Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files(the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and / or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER 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. +# +# library_static, library_shared, binary +cc_@module { + name: "@name", + + vendor: true, + + defaults: [ +@defaults + ], + + srcs: [ +@srcs + ], + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + local_include_dirs: [ +@local_include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} diff --git a/clinfo.bp b/clinfo.bp new file mode 100644 index 0000000..8c03d68 --- /dev/null +++ b/clinfo.bp @@ -0,0 +1,34 @@ +cc_binary { + name: "clinfo", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "clinfo/OpenCLInfo.cpp", + ], + + cflags: [ + "-O3", + "-DNDEBUG", + "-DCL_TARGET_OPENCL_VERSION=300", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + ], + + shared_libs: [ + "libOpenCL", + ], + + static_libs: [ + ], + +} diff --git a/clinfo/OpenCLInfo.cpp b/clinfo/OpenCLInfo.cpp new file mode 100755 index 0000000..06931ab --- /dev/null +++ b/clinfo/OpenCLInfo.cpp @@ -0,0 +1,815 @@ +// +// Book: OpenCL(R) Programming Guide +// Authors: Aaftab Munshi, Benedict Gaster, Dan Ginsburg, Timothy Mattson +// ISBN-10: ?????????? +// ISBN-13: ????????????? +// Publisher: Addison-Wesley Professional +// URLs: http://safari.informit.com/?????????? +// http://www.????????.com +// + +// OpenCLInfo.cpp +// +// This is a simple example that demonstrates use of the clGetInfo* functions, +// with particular focus on platforms and their associated devices. + +#include +#include +#include + +#if defined(_WIN32) +#include // needed for alloca +#endif // _WIN32 + +#if defined(linux) || defined(__APPLE__) || defined(__MACOSX) +# include +#endif // linux + +#ifdef __APPLE__ +#include +#else +#include +#endif + +/// +// Display information for a particular platform. +// Assumes that all calls to clGetPlatformInfo returns +// a value of type char[], which is valid for OpenCL 1.1. +// +void DisplayPlatformInfo( + cl_platform_id id, + cl_platform_info name, + std::string str) +{ + cl_int errNum; + std::size_t paramValueSize; + + errNum = clGetPlatformInfo( + id, + name, + 0, + NULL, + ¶mValueSize); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL platform " << str << "." << std::endl; + return; + } + + char * info = (char *)alloca(sizeof(char) * paramValueSize); + errNum = clGetPlatformInfo( + id, + name, + paramValueSize, + info, + NULL); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL platform " << str << "." << std::endl; + return; + } + + std::cout << "\t" << str << ":\t" << info << std::endl; +} + +template +void appendBitfield(T info, T value, std::string name, std::string & str) +{ + if (info & value) + { + if (str.length() > 0) + { + str.append(" | "); + } + str.append(name); + } +} + +/// +// Display information for a particular device. +// As different calls to clGetDeviceInfo may return +// values of different types a template is used. +// As some values returned are arrays of values, a templated class is +// used so it can be specialized for this case, see below. +// +template +class InfoDevice +{ +public: + static void display( + cl_device_id id, + cl_device_info name, + std::string str) + { + cl_int errNum; + std::size_t paramValueSize; + + errNum = clGetDeviceInfo( + id, + name, + 0, + NULL, + ¶mValueSize); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL device info " << str << "." << std::endl; + return; + } + + T * info = (T *)alloca(sizeof(T) * paramValueSize); + errNum = clGetDeviceInfo( + id, + name, + paramValueSize, + info, + NULL); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL device info " << str << "." << std::endl; + return; + } + + // Handle a few special cases + switch (name) + { + case CL_DEVICE_TYPE: + { + std::string deviceType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_DEVICE_TYPE_CPU, + "CL_DEVICE_TYPE_CPU", + deviceType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_DEVICE_TYPE_GPU, + "CL_DEVICE_TYPE_GPU", + deviceType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_DEVICE_TYPE_ACCELERATOR, + "CL_DEVICE_TYPE_ACCELERATOR", + deviceType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_DEVICE_TYPE_DEFAULT, + "CL_DEVICE_TYPE_DEFAULT", + deviceType); + + std::cout << "\t\t" << str << ":\t" << deviceType << std::endl; + } + break; + case CL_DEVICE_SINGLE_FP_CONFIG: + { + std::string fpType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_DENORM, + "CL_FP_DENORM", + fpType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_INF_NAN, + "CL_FP_INF_NAN", + fpType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_ROUND_TO_NEAREST, + "CL_FP_ROUND_TO_NEAREST", + fpType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_ROUND_TO_ZERO, + "CL_FP_ROUND_TO_ZERO", + fpType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_ROUND_TO_INF, + "CL_FP_ROUND_TO_INF", + fpType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_FMA, + "CL_FP_FMA", + fpType); + +#ifdef CL_FP_SOFT_FLOAT + appendBitfield( + *(reinterpret_cast(info)), + CL_FP_SOFT_FLOAT, + "CL_FP_SOFT_FLOAT", + fpType); +#endif + + std::cout << "\t\t" << str << ":\t" << fpType << std::endl; + } + case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE: + { + std::string memType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_NONE, + "CL_NONE", + memType); + appendBitfield( + *(reinterpret_cast(info)), + CL_READ_ONLY_CACHE, + "CL_READ_ONLY_CACHE", + memType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_READ_WRITE_CACHE, + "CL_READ_WRITE_CACHE", + memType); + + std::cout << "\t\t" << str << ":\t" << memType << std::endl; + } + break; + case CL_DEVICE_LOCAL_MEM_TYPE: + { + std::string memType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_GLOBAL, + "CL_LOCAL", + memType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_GLOBAL, + "CL_GLOBAL", + memType); + + std::cout << "\t\t" << str << ":\t" << memType << std::endl; + } + break; + case CL_DEVICE_EXECUTION_CAPABILITIES: + { + std::string memType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_EXEC_KERNEL, + "CL_EXEC_KERNEL", + memType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_EXEC_NATIVE_KERNEL, + "CL_EXEC_NATIVE_KERNEL", + memType); + + std::cout << "\t\t" << str << ":\t" << memType << std::endl; + } + break; + case CL_DEVICE_QUEUE_PROPERTIES: + { + std::string memType; + + appendBitfield( + *(reinterpret_cast(info)), + CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, + "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE", + memType); + + appendBitfield( + *(reinterpret_cast(info)), + CL_QUEUE_PROFILING_ENABLE, + "CL_QUEUE_PROFILING_ENABLE", + memType); + + std::cout << "\t\t" << str << ":\t" << memType << std::endl; + } + break; + default: + std::cout << "\t\t" << str << ":\t" << *info << std::endl; + break; + } + } +}; + +/// +// Simple trait class used to wrap base types. +// +template +class ArrayType +{ +public: + static bool isChar() { return false; } +}; + +/// +// Specialized for the char (i.e. null terminated string case). +// +template<> +class ArrayType +{ +public: + static bool isChar() { return true; } +}; + +/// +// Specialized instance of class InfoDevice for array types. +// +template +class InfoDevice > +{ +public: + static void display( + cl_device_id id, + cl_device_info name, + std::string str) + { + cl_int errNum; + std::size_t paramValueSize; + + errNum = clGetDeviceInfo( + id, + name, + 0, + NULL, + ¶mValueSize); + if (errNum != CL_SUCCESS) + { + std::cerr + << "Failed to find OpenCL device info " + << str + << "." + << std::endl; + return; + } + + T * info = (T *)alloca(sizeof(T) * paramValueSize); + errNum = clGetDeviceInfo( + id, + name, + paramValueSize, + info, + NULL); + if (errNum != CL_SUCCESS) + { + std::cerr + << "Failed to find OpenCL device info " + << str + << "." + << std::endl; + return; + } + + if (ArrayType::isChar()) + { + std::cout << "\t" << str << ":\t" << info << std::endl; + } + else if (name == CL_DEVICE_MAX_WORK_ITEM_SIZES) + { + cl_uint maxWorkItemDimensions; + + errNum = clGetDeviceInfo( + id, + CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, + sizeof(cl_uint), + &maxWorkItemDimensions, + NULL); + if (errNum != CL_SUCCESS) + { + std::cerr + << "Failed to find OpenCL device info " + << "CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS." + << std::endl; + return; + } + + std::cout << "\t" << str << ":\t" ; + for (cl_uint i = 0; i < maxWorkItemDimensions; i++) + { + std::cout << info[i] << " "; + } + std::cout << std::endl; + } + } +}; + +/// +// Enumerate platforms and display information about them +// and their associated devices. +// +void displayInfo(void) +{ + cl_int errNum; + cl_uint numPlatforms; + cl_platform_id * platformIds; + cl_context context = NULL; + + // First, query the total number of platforms + errNum = clGetPlatformIDs(0, NULL, &numPlatforms); + if (errNum != CL_SUCCESS || numPlatforms <= 0) + { + std::cerr << "Failed to find any OpenCL platform." << std::endl; + return; + } + + // Next, allocate memory for the installed plaforms, and qeury + // to get the list. + platformIds = (cl_platform_id *)alloca(sizeof(cl_platform_id) * numPlatforms); + // First, query the total number of platforms + errNum = clGetPlatformIDs(numPlatforms, platformIds, NULL); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find any OpenCL platforms." << std::endl; + return; + } + + std::cout << "Number of platforms: \t" << numPlatforms << std::endl; + // Iterate through the list of platforms displaying associated information + for (cl_uint i = 0; i < numPlatforms; i++) { + // First we display information associated with the platform + DisplayPlatformInfo( + platformIds[i], + CL_PLATFORM_PROFILE, + "CL_PLATFORM_PROFILE"); + DisplayPlatformInfo( + platformIds[i], + CL_PLATFORM_VERSION, + "CL_PLATFORM_VERSION"); + DisplayPlatformInfo( + platformIds[i], + CL_PLATFORM_VENDOR, + "CL_PLATFORM_VENDOR"); + DisplayPlatformInfo( + platformIds[i], + CL_PLATFORM_EXTENSIONS, + "CL_PLATFORM_EXTENSIONS"); + + // Now query the set of devices associated with the platform + cl_uint numDevices; + errNum = clGetDeviceIDs( + platformIds[i], + CL_DEVICE_TYPE_ALL, + 0, + NULL, + &numDevices); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL devices." << std::endl; + return; + } + + cl_device_id * devices = (cl_device_id *)alloca(sizeof(cl_device_id) * numDevices); + errNum = clGetDeviceIDs( + platformIds[i], + CL_DEVICE_TYPE_ALL, + numDevices, + devices, + NULL); + if (errNum != CL_SUCCESS) + { + std::cerr << "Failed to find OpenCL devices." << std::endl; + return; + } + + std::cout << "\tNumber of devices: \t" << numDevices << std::endl; + // Iterate through each device, displaying associated information + for (cl_uint j = 0; j < numDevices; j++) + { + InfoDevice::display( + devices[j], + CL_DEVICE_TYPE, + "CL_DEVICE_TYPE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_VENDOR_ID, + "CL_DEVICE_VENDOR_ID"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_COMPUTE_UNITS, + "CL_DEVICE_MAX_COMPUTE_UNITS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, + "CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS"); + + InfoDevice >::display( + devices[j], + CL_DEVICE_MAX_WORK_ITEM_SIZES, + "CL_DEVICE_MAX_WORK_ITEM_SIZES"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_WORK_GROUP_SIZE, + "CL_DEVICE_MAX_WORK_GROUP_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE"); + +#ifdef CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF + + InfoDevice::display( + devices[j], + CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF, + "CL_DEVICE_PREFERRED_VECTOR_WIDTH_HALF"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_CHAR"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_SHORT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_INT, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_INT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_LONG"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_FLOAT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF, + "CL_DEVICE_NATIVE_VECTOR_WIDTH_HALF"); +#endif + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_CLOCK_FREQUENCY, + "CL_DEVICE_MAX_CLOCK_FREQUENCY"); + + InfoDevice::display( + devices[j], + CL_DEVICE_ADDRESS_BITS, + "CL_DEVICE_ADDRESS_BITS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_MEM_ALLOC_SIZE, + "CL_DEVICE_MAX_MEM_ALLOC_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE_SUPPORT, + "CL_DEVICE_IMAGE_SUPPORT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_READ_IMAGE_ARGS, + "CL_DEVICE_MAX_READ_IMAGE_ARGS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_WRITE_IMAGE_ARGS, + "CL_DEVICE_MAX_WRITE_IMAGE_ARGS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE2D_MAX_WIDTH, + "CL_DEVICE_IMAGE2D_MAX_WIDTH"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE2D_MAX_WIDTH, + "CL_DEVICE_IMAGE2D_MAX_WIDTH"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE2D_MAX_HEIGHT, + "CL_DEVICE_IMAGE2D_MAX_HEIGHT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE3D_MAX_WIDTH, + "CL_DEVICE_IMAGE3D_MAX_WIDTH"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE3D_MAX_HEIGHT, + "CL_DEVICE_IMAGE3D_MAX_HEIGHT"); + + InfoDevice::display( + devices[j], + CL_DEVICE_IMAGE3D_MAX_DEPTH, + "CL_DEVICE_IMAGE3D_MAX_DEPTH"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_SAMPLERS, + "CL_DEVICE_MAX_SAMPLERS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_PARAMETER_SIZE, + "CL_DEVICE_MAX_PARAMETER_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MEM_BASE_ADDR_ALIGN, + "CL_DEVICE_MEM_BASE_ADDR_ALIGN"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, + "CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_SINGLE_FP_CONFIG, + "CL_DEVICE_SINGLE_FP_CONFIG"); + + InfoDevice::display( + devices[j], + CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, + "CL_DEVICE_GLOBAL_MEM_CACHE_TYPE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, + "CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, + "CL_DEVICE_GLOBAL_MEM_CACHE_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_GLOBAL_MEM_SIZE, + "CL_DEVICE_GLOBAL_MEM_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, + "CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_MAX_CONSTANT_ARGS, + "CL_DEVICE_MAX_CONSTANT_ARGS"); + + InfoDevice::display( + devices[j], + CL_DEVICE_LOCAL_MEM_TYPE, + "CL_DEVICE_LOCAL_MEM_TYPE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_LOCAL_MEM_SIZE, + "CL_DEVICE_LOCAL_MEM_SIZE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_ERROR_CORRECTION_SUPPORT, + "CL_DEVICE_ERROR_CORRECTION_SUPPORT"); + +#ifdef CL_DEVICE_HOST_UNIFIED_MEMORY + InfoDevice::display( + devices[j], + CL_DEVICE_HOST_UNIFIED_MEMORY, + "CL_DEVICE_HOST_UNIFIED_MEMORY"); +#endif + + InfoDevice::display( + devices[j], + CL_DEVICE_PROFILING_TIMER_RESOLUTION, + "CL_DEVICE_PROFILING_TIMER_RESOLUTION"); + + InfoDevice::display( + devices[j], + CL_DEVICE_ENDIAN_LITTLE, + "CL_DEVICE_ENDIAN_LITTLE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_AVAILABLE, + "CL_DEVICE_AVAILABLE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_COMPILER_AVAILABLE, + "CL_DEVICE_COMPILER_AVAILABLE"); + + InfoDevice::display( + devices[j], + CL_DEVICE_EXECUTION_CAPABILITIES, + "CL_DEVICE_EXECUTION_CAPABILITIES"); + + InfoDevice::display( + devices[j], + CL_DEVICE_QUEUE_PROPERTIES, + "CL_DEVICE_QUEUE_PROPERTIES"); + + InfoDevice::display( + devices[j], + CL_DEVICE_PLATFORM, + "CL_DEVICE_PLATFORM"); + + InfoDevice >::display( + devices[j], + CL_DEVICE_NAME, + "CL_DEVICE_NAME"); + + InfoDevice >::display( + devices[j], + CL_DEVICE_VENDOR, + "CL_DEVICE_VENDOR"); + + InfoDevice >::display( + devices[j], + CL_DRIVER_VERSION, + "CL_DRIVER_VERSION"); + + InfoDevice >::display( + devices[j], + CL_DEVICE_PROFILE, + "CL_DEVICE_PROFILE"); + + InfoDevice >::display( + devices[j], + CL_DEVICE_VERSION, + "CL_DEVICE_VERSION"); + +#ifdef CL_DEVICE_OPENCL_C_VERSION + InfoDevice >::display( + devices[j], + CL_DEVICE_OPENCL_C_VERSION, + "CL_DEVICE_OPENCL_C_VERSION"); +#endif + + InfoDevice >::display( + devices[j], + CL_DEVICE_EXTENSIONS, + "CL_DEVICE_EXTENSIONS"); + + + std::cout << std::endl << std::endl; + } + } +} + +/// +// main() for OpenCLInfo example +// +int main(int argc, char** argv) +{ + cl_context context = 0; + + displayInfo(); + + return 0; +} diff --git a/cmake/JoinPaths.cmake b/cmake/JoinPaths.cmake new file mode 100644 index 0000000..32d6d66 --- /dev/null +++ b/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/icd_loader_test.bp b/icd_loader_test.bp new file mode 100644 index 0000000..9017359 --- /dev/null +++ b/icd_loader_test.bp @@ -0,0 +1,47 @@ +cc_binary { + name: "icd_loader_test", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/loader_test/test_kernel.c", + "test/loader_test/main.c", + "test/loader_test/test_platforms.c", + "test/loader_test/icd_test_match.c", + "test/loader_test/test_program_objects.c", + "test/loader_test/test_sampler_objects.c", + "test/loader_test/test_buffer_object.c", + "test/loader_test/test_cl_runtime.c", + "test/loader_test/callbacks.c", + "test/loader_test/test_create_calls.c", + "test/loader_test/test_clgl.c", + "test/loader_test/test_image_objects.c", + ], + + cflags: [ + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "test/inc", + ], + + shared_libs: [ + "libOpenCL", + "libIcdLog", + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/inc/README.txt b/inc/README.txt index 9209d44..a52b211 100644 --- a/inc/README.txt +++ b/inc/README.txt @@ -6,7 +6,6 @@ inc/CL/cl_d3d11.h inc/CL/cl_dx9_media_sharing.h inc/CL/cl_egl.h inc/CL/cl_ext.h -inc/CL/cl_gl_ext.h inc/CL/cl_gl.h inc/CL/cl.h inc/CL/cl.hpp diff --git a/libIcdLog.bp b/libIcdLog.bp new file mode 100644 index 0000000..ad9f887 --- /dev/null +++ b/libIcdLog.bp @@ -0,0 +1,37 @@ +cc_library_shared { + name: "libIcdLog", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/log/icd_test_log.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DIcdLog_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "test/inc", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/libOpenCL.bp b/libOpenCL.bp new file mode 100644 index 0000000..cb11698 --- /dev/null +++ b/libOpenCL.bp @@ -0,0 +1,46 @@ +cc_library_shared { + name: "libOpenCL", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "loader/icd.c", + "loader/icd_dispatch.c", + "loader/icd_dispatch_generated.c", + "loader/linux/icd_linux.c", + "loader/linux/icd_linux_envvars.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_ENABLE_LAYERS", + "-DCL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DOPENCL_ICD_LOADER_VERSION_MAJOR=3", + "-DOPENCL_ICD_LOADER_VERSION_MINOR=0", + "-DOPENCL_ICD_LOADER_VERSION_REV=6", + "-DOpenCL_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "loader", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/libOpenCLDriverStub.bp b/libOpenCLDriverStub.bp new file mode 100644 index 0000000..0f499bc --- /dev/null +++ b/libOpenCLDriverStub.bp @@ -0,0 +1,40 @@ +cc_library_shared { + name: "libOpenCLDriverStub", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/driver_stub/cl.c", + "test/driver_stub/cl_ext.c", + "test/driver_stub/cl_gl.c", + "test/driver_stub/icd.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DOpenCLDriverStub_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "test/inc", + ], + + shared_libs: [ + "libIcdLog", + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/loader/cllayerinfo.c b/loader/cllayerinfo.c new file mode 100644 index 0000000..5a85ba8 --- /dev/null +++ b/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/loader/icd.c b/loader/icd.c index ea8306a..bbd6ec3 100644 --- a/loader/icd.c +++ b/loader/icd.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2019 The Khronos Group Inc. + * 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. @@ -19,10 +19,31 @@ #include "icd.h" #include "icd_dispatch.h" #include "icd_envvars.h" +#if defined(CL_ENABLE_LAYERS) +#include +#endif // defined(CL_ENABLE_LAYERS) #include #include KHRicdVendor *khrIcdVendors = NULL; +int khrEnableTrace = 0; + +#if defined(CL_ENABLE_LAYERS) +struct KHRLayer *khrFirstLayer = NULL; +#endif // defined(CL_ENABLE_LAYERS) + +// entrypoint to check and initialize trace. +void khrIcdInitializeTrace(void) +{ + char *enableTrace = khrIcd_getenv("OCL_ICD_ENABLE_TRACE"); + if (enableTrace && (strcmp(enableTrace, "True") == 0 || + strcmp(enableTrace, "true") == 0 || + strcmp(enableTrace, "T") == 0 || + strcmp(enableTrace, "1") == 0)) + { + khrEnableTrace = 1; + } +} // entrypoint to initialize the ICD and add all vendors void khrIcdInitialize(void) @@ -189,6 +210,143 @@ void khrIcdVendorAdd(const char *libraryName) } } +#if defined(CL_ENABLE_LAYERS) +void khrIcdLayerAdd(const char *libraryName) +{ + void *library = NULL; + cl_int result = CL_SUCCESS; + pfn_clGetLayerInfo p_clGetLayerInfo = NULL; + pfn_clInitLayer p_clInitLayer = NULL; + struct KHRLayer *layerIterator = NULL; + struct KHRLayer *layer = NULL; + cl_layer_api_version api_version = 0; + const struct _cl_icd_dispatch *targetDispatch = NULL; + const struct _cl_icd_dispatch *layerDispatch = NULL; + cl_uint layerDispatchNumEntries = 0; + cl_uint loaderDispatchNumEntries = 0; + + // require that the library name be valid + if (!libraryName) + { + goto Done; + } + KHR_ICD_TRACE("attempting to add layer %s...\n", libraryName); + + // load its library and query its function pointers + library = khrIcdOsLibraryLoad(libraryName); + if (!library) + { + KHR_ICD_TRACE("failed to load library %s\n", libraryName); + goto Done; + } + + // ensure that we haven't already loaded this layer + for (layerIterator = khrFirstLayer; layerIterator; layerIterator = layerIterator->next) + { + if (layerIterator->library == library) + { + KHR_ICD_TRACE("already loaded layer %s, nothing to do here\n", libraryName); + goto Done; + } + } + + // get the library's clGetLayerInfo pointer + p_clGetLayerInfo = (pfn_clGetLayerInfo)(size_t)khrIcdOsLibraryGetFunctionAddress(library, "clGetLayerInfo"); + if (!p_clGetLayerInfo) + { + KHR_ICD_TRACE("failed to get function address clGetLayerInfo\n"); + goto Done; + } + + // use that function to get the clInitLayer function pointer + p_clInitLayer = (pfn_clInitLayer)(size_t)khrIcdOsLibraryGetFunctionAddress(library, "clInitLayer"); + if (!p_clInitLayer) + { + KHR_ICD_TRACE("failed to get function address clInitLayer\n"); + goto Done; + } + + result = p_clGetLayerInfo(CL_LAYER_API_VERSION, sizeof(api_version), &api_version, NULL); + if (CL_SUCCESS != result) + { + KHR_ICD_TRACE("failed to query layer version\n"); + goto Done; + } + + if (CL_LAYER_API_VERSION_100 != api_version) + { + KHR_ICD_TRACE("unsupported api version\n"); + goto Done; + } + + layer = (struct KHRLayer*)calloc(sizeof(struct KHRLayer), 1); + if (!layer) + { + 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); + } else { + targetDispatch = &khrMasterDispatch; + } + + loaderDispatchNumEntries = sizeof(khrMasterDispatch)/sizeof(void*); + result = p_clInitLayer( + loaderDispatchNumEntries, + targetDispatch, + &layerDispatchNumEntries, + &layerDispatch); + if (CL_SUCCESS != result) + { + KHR_ICD_TRACE("failed to initialize layer\n"); + goto Done; + } + + layer->next = khrFirstLayer; + khrFirstLayer = layer; + layer->library = library; + + cl_uint limit = layerDispatchNumEntries < loaderDispatchNumEntries ? layerDispatchNumEntries : loaderDispatchNumEntries; + + for (cl_uint i = 0; i < limit; i++) { + ((void **)&(layer->dispatch))[i] = + ((void **)layerDispatch)[i] ? + ((void **)layerDispatch)[i] : ((void **)targetDispatch)[i]; + } + for (cl_uint i = limit; i < loaderDispatchNumEntries; i++) { + ((void **)&(layer->dispatch))[i] = ((void **)targetDispatch)[i]; + } + + KHR_ICD_TRACE("successfully added layer %s\n", libraryName); + return; +Done: + if (library) + { + khrIcdOsLibraryUnload(library); + } + if (layer) + { + free(layer); + } +} +#endif // defined(CL_ENABLE_LAYERS) + // Get next file or dirname given a string list or registry key path. // Note: the input string may be modified! static char *loader_get_next_path(char *path) { @@ -229,6 +387,29 @@ void khrIcdVendorsEnumerateEnv(void) } } +#if defined(CL_ENABLE_LAYERS) +void khrIcdLayersEnumerateEnv(void) +{ + char* layerFilenames = khrIcd_secure_getenv("OPENCL_LAYERS"); + char* cur_file = NULL; + char* next_file = NULL; + if (layerFilenames) + { + KHR_ICD_TRACE("Found OPENCL_LAYERS environment variable.\n"); + + next_file = layerFilenames; + while (NULL != next_file && *next_file != '\0') { + cur_file = next_file; + next_file = loader_get_next_path(cur_file); + + khrIcdLayerAdd(cur_file); + } + + khrIcd_free_getenv(layerFilenames); + } +} +#endif // defined(CL_ENABLE_LAYERS) + void khrIcdContextPropertiesGetPlatform(const cl_context_properties *properties, cl_platform_id *outPlatform) { if (properties == NULL && khrIcdVendors != NULL) diff --git a/loader/icd.h b/loader/icd.h index 34751e9..93723aa 100644 --- a/loader/icd.h +++ b/loader/icd.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2019 The Khronos Group Inc. + * 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. @@ -33,26 +33,40 @@ #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 +#include /* * 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; @@ -83,6 +97,36 @@ struct KHRicdVendorRec // the global state extern KHRicdVendor * khrIcdVendors; +extern int khrEnableTrace; + +#if defined(CL_ENABLE_LAYERS) +/* + * KHRLayer + * + * Data for a single Layer + */ +struct KHRLayer; +struct KHRLayer +{ + // the loaded library object (true type varies on Linux versus Windows) + void *library; + // the dispatch table of the layer + 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 +extern struct KHRLayer * khrFirstLayer; +extern struct _cl_icd_dispatch khrMasterDispatch; +#endif // defined(CL_ENABLE_LAYERS) + /* * khrIcd interface */ @@ -94,6 +138,9 @@ extern KHRicdVendor * khrIcdVendors; // 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 @@ -105,6 +152,12 @@ void khrIcdVendorsEnumerateEnv(void); // add a vendor's implementation to the list of libraries void khrIcdVendorAdd(const char *libraryName); +// read layers from environment variables +void khrIcdLayersEnumerateEnv(void); + +// add a layer to the layer chain +void khrIcdLayerAdd(const char *libraryName); + // dynamically load a library. returns NULL on failure // n.b, this call is OS-specific void *khrIcdOsLibraryLoad(const char *libraryName); @@ -123,63 +176,71 @@ void khrIcdContextPropertiesGetPlatform( cl_platform_id *outPlatform); // internal tracing macros -#if 0 - #include - #define KHR_ICD_TRACE(...) \ - do \ +#define KHR_ICD_TRACE(...) \ +do \ +{ \ + if (khrEnableTrace) \ { \ fprintf(stderr, "KHR ICD trace at %s:%d: ", __FILE__, __LINE__); \ fprintf(stderr, __VA_ARGS__); \ - } while (0) + } \ +} while (0) + #ifdef _WIN32 #define KHR_ICD_WIDE_TRACE(...) \ - do \ +do \ +{ \ + if (khrEnableTrace) \ { \ fwprintf(stderr, L"KHR ICD trace at %hs:%d: ", __FILE__, __LINE__); \ fwprintf(stderr, __VA_ARGS__); \ - } while (0) + } \ +} while (0) + #else #define KHR_ICD_WIDE_TRACE(...) -#endif - #define KHR_ICD_ASSERT(x) \ - do \ - { \ - if (!(x)) \ - { \ - fprintf(stderr, "KHR ICD assert at %s:%d: %s failed", __FILE__, __LINE__, #x); \ - } \ - } while (0) -#else - #define KHR_ICD_TRACE(...) - #define KHR_ICD_WIDE_TRACE(...) - #define KHR_ICD_ASSERT(x) #endif -// 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; \ - } \ - } 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; \ - } \ - } while (0) - +// 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) + +// 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) + +// 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/loader/icd_dispatch.c b/loader/icd_dispatch.c index df967cb..3eb18d2 100644 --- a/loader/icd_dispatch.c +++ b/loader/icd_dispatch.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2019 The Khronos Group Inc. + * Copyright (c) 2012-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. @@ -16,23 +16,146 @@ * 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 -// Platform APIs -CL_API_ENTRY cl_int CL_API_CALL -clGetPlatformIDs(cl_uint num_entries, - cl_platform_id * platforms, - cl_uint * num_platforms) CL_API_SUFFIX__VERSION_1_0 +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; + void * pv; + +#define KHR_ICD_CASE_STRING_PARAM_NAME(name) \ + case CL_ICDL_ ## name: \ + pvs = strlen(cl_icdl_ ## name) + 1; \ + pv = (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, +// do not need to be ICD-aware and do not require any ICD loader +// modifications. The KHR and EXT extensions below were added for +// backwards compatibility only. +#define KHR_ICD_CHECK_EXTENSION_FUNCTION(name) \ + do \ + { \ + if (!strcmp(function_name, #name)) \ + { \ + return (void*)(size_t)&name; \ + } \ + } while (0) + + // Functions supporting the creation of OpenCL Memory Objects + // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing) + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLBuffer); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture2D); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLTexture3D); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromGLRenderbuffer); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLObjectInfo); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLTextureInfo); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireGLObjects); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseGLObjects); + + // cl_khr_gl_sharing + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetGLContextInfoKHR); + + // cl_khr_gl_event + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateEventFromGLsyncKHR); + +#if defined(_WIN32) + // cl_khr_d3d10_sharing + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromD3D10KHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10BufferKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10Texture2DKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D10Texture3DKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireD3D10ObjectsKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseD3D10ObjectsKHR); + // cl_khr_d3d11_sharing + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromD3D11KHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11BufferKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11Texture2DKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromD3D11Texture3DKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireD3D11ObjectsKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseD3D11ObjectsKHR); + // cl_khr_dx9_media_sharing + KHR_ICD_CHECK_EXTENSION_FUNCTION(clGetDeviceIDsFromDX9MediaAdapterKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromDX9MediaSurfaceKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireDX9MediaSurfacesKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseDX9MediaSurfacesKHR); +#endif + + // cl_ext_device_fission + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateSubDevicesEXT); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clRetainDeviceEXT); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clReleaseDeviceEXT); + + // cl_khr_egl_image + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateFromEGLImageKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueAcquireEGLObjectsKHR); + KHR_ICD_CHECK_EXTENSION_FUNCTION(clEnqueueReleaseEGLObjectsKHR); + + // cl_khr_egl_event + KHR_ICD_CHECK_EXTENSION_FUNCTION(clCreateEventFromEGLSyncKHR); + + // 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; +} + +#ifdef __cplusplus +extern "C" { +#endif + +static inline cl_int clGetPlatformIDs_body( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms) { KHRicdVendor* vendor = NULL; cl_uint i; - // initialize the platforms (in case they have not been already) - khrIcdInitialize(); - if (!num_entries && platforms) { return CL_INVALID_VALUE; @@ -42,11 +165,11 @@ clGetPlatformIDs(cl_uint num_entries, return CL_INVALID_VALUE; } // set num_platforms to 0 and set all platform pointers to NULL - if (num_platforms) + if (num_platforms) { *num_platforms = 0; } - for (i = 0; i < num_entries && platforms; ++i) + for (i = 0; i < num_entries && platforms; ++i) { platforms[i] = NULL; } @@ -71,2604 +194,146 @@ clGetPlatformIDs(cl_uint num_entries, return CL_SUCCESS; } -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 +cl_int CL_API_CALL clGetPlatformIDs_disp( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms) { - // initialize the platforms (in case they have not been already) - khrIcdInitialize(); - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetPlatformInfo( - platform, - param_name, - param_value_size, - param_value, - param_value_size_ret); + return clGetPlatformIDs_body( + num_entries, + platforms, + num_platforms); } -// 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 clGetPlatformIDs( + cl_uint num_entries, + cl_platform_id* platforms, + cl_uint* num_platforms) { // initialize the platforms (in case they have not been already) khrIcdInitialize(); - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetDeviceIDs( - platform, - device_type, - num_entries, - devices, - num_devices); -} -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clGetDeviceInfo( - device, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clCreateSubDevices(cl_device_id in_device, - const cl_device_partition_property * properties, - cl_uint num_entries, - cl_device_id * out_devices, - cl_uint * num_devices) CL_API_SUFFIX__VERSION_1_2 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); - return in_device->dispatch->clCreateSubDevices( - in_device, - properties, +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetPlatformIDs( + num_entries, + platforms, + num_platforms); +#endif // defined(CL_ENABLE_LAYERS) + return clGetPlatformIDs_body( num_entries, - out_devices, - num_devices); + platforms, + num_platforms); } -CL_API_ENTRY cl_int CL_API_CALL -clRetainDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 +static inline void* clGetExtensionFunctionAddress_body( + const char* function_name) { - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clRetainDevice(device); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseDevice(cl_device_id device) CL_API_SUFFIX__VERSION_1_2 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clReleaseDevice(device); -} + void* function_address = NULL; + size_t function_name_length = 0; + KHRicdVendor* vendor = NULL; -// Context APIs -CL_API_ENTRY cl_context CL_API_CALL -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 -{ - // initialize the platforms (in case they have not been already) - khrIcdInitialize(); - if (!num_devices || !devices) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); + + // check if this is an ICD-aware extension + function_address = khrIcdGetExtensionFunctionAddress(function_name); + if (function_address) + { + return function_address; + } + + // fall back to vendor extension detection + function_name_length = strlen(function_name); + for (vendor = khrIcdVendors; vendor; vendor = vendor->next) { - if (errcode_ret) + size_t vendor_suffix_length = strlen(vendor->suffix); + if (vendor_suffix_length <= function_name_length && + vendor_suffix_length > 0) { - *errcode_ret = CL_INVALID_VALUE; + const char* function_suffix = + function_name + function_name_length - vendor_suffix_length; + if (!strcmp(function_suffix, vendor->suffix)) + { + return vendor->clGetExtensionFunctionAddress(function_name); + } } - return NULL; } - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE); - return devices[0]->dispatch->clCreateContext( - properties, - num_devices, - devices, - pfn_notify, - user_data, - errcode_ret); -} - -CL_API_ENTRY cl_context CL_API_CALL -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 -{ - cl_platform_id platform = NULL; - - // initialize the platforms (in case they have not been already) - khrIcdInitialize(); - - // determine the platform to use from the properties specified - khrIcdContextPropertiesGetPlatform(properties, &platform); - - // validate the platform handle and dispatch - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clCreateContextFromType( - properties, - device_type, - pfn_notify, - user_data, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); - return context->dispatch->clRetainContext(context); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseContext(cl_context context) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); - return context->dispatch->clReleaseContext(context); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); - return context->dispatch->clGetContextInfo( - context, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -// Command Queue APIs -CL_API_ENTRY cl_command_queue CL_API_CALL -clCreateCommandQueue(cl_context context, - cl_device_id device, - cl_command_queue_properties properties, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateCommandQueue( - context, - device, - properties, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clRetainCommandQueue(command_queue); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseCommandQueue(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clReleaseCommandQueue(command_queue); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clGetCommandQueueInfo( - command_queue, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -// Memory Object APIs -CL_API_ENTRY cl_mem CL_API_CALL -clCreateBuffer(cl_context context, - cl_mem_flags flags, - size_t size, - void * host_ptr, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateBuffer( - context, - flags, - size, - host_ptr, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateImage( - context, - flags, - image_format, - image_desc, - host_ptr, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clRetainMemObject(memobj); -} - - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clReleaseMemObject(memobj); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); - return context->dispatch->clGetSupportedImageFormats( - context, - flags, - image_type, - num_entries, - image_formats, - num_image_formats); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clGetMemObjectInfo( - memobj, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT); - return image->dispatch->clGetImageInfo( - image, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} -// Sampler APIs -CL_API_ENTRY cl_sampler CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateSampler( - context, - normalized_coords, - addressing_mode, - filter_mode, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); - return sampler->dispatch->clRetainSampler(sampler); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseSampler(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); - return sampler->dispatch->clReleaseSampler(sampler); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); - return sampler->dispatch->clGetSamplerInfo( - sampler, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -// Program Object APIs -CL_API_ENTRY cl_program CL_API_CALL -clCreateProgramWithSource(cl_context context, - cl_uint count, - const char ** strings, - const size_t * lengths, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateProgramWithSource( - context, - count, - strings, - lengths, - errcode_ret); -} - -CL_API_ENTRY cl_program CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateProgramWithBinary( - context, - num_devices, - device_list, - lengths, - binaries, - binary_status, - errcode_ret); -} - -CL_API_ENTRY cl_program CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateProgramWithBuiltInKernels( - context, - num_devices, - device_list, - kernel_names, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clRetainProgram(program); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseProgram(cl_program program) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clReleaseProgram(program); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clBuildProgram( - program, - num_devices, - device_list, - options, - pfn_notify, - user_data); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clCompileProgram( - program, - num_devices, - device_list, - options, - num_input_headers, - input_headers, - header_include_names, - pfn_notify, - user_data); -} - -CL_API_ENTRY cl_program CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clLinkProgram( - context, - num_devices, - device_list, - options, - num_input_programs, - input_programs, - pfn_notify, - user_data, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetProgramSpecializationConstant(cl_program program, - cl_uint spec_id, - size_t spec_size, - const void* spec_value) CL_API_SUFFIX__VERSION_2_2 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clSetProgramSpecializationConstant( - program, - spec_id, - spec_size, - spec_value); + return NULL; } -CL_API_ENTRY cl_int CL_API_CALL -clSetProgramReleaseCallback(cl_program program, - void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), - void * user_data) CL_API_SUFFIX__VERSION_2_2 +void* CL_API_CALL clGetExtensionFunctionAddress_disp( + const char* function_name) { - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clSetProgramReleaseCallback( - program, - pfn_notify, - user_data); + return clGetExtensionFunctionAddress_body( + function_name); } -CL_API_ENTRY cl_int CL_API_CALL -clUnloadPlatformCompiler(cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 +CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddress( + const char* function_name) { - // initialize the platforms (in case they have not been already) + // make sure the ICD is initialized khrIcdInitialize(); - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clUnloadPlatformCompiler(platform); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clGetProgramInfo( - program, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clGetProgramBuildInfo( - program, - device, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -// Kernel Object APIs -CL_API_ENTRY cl_kernel CL_API_CALL -clCreateKernel(cl_program program, - const char * kernel_name, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM); - return program->dispatch->clCreateKernel( - program, - kernel_name, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clCreateKernelsInProgram(cl_program program, - cl_uint num_kernels, - cl_kernel * kernels, - cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); - return program->dispatch->clCreateKernelsInProgram( - program, - num_kernels, - kernels, - num_kernels_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clRetainKernel(kernel); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseKernel(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clReleaseKernel(kernel); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetKernelArg(cl_kernel kernel, - cl_uint arg_index, - size_t arg_size, - const void * arg_value) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clSetKernelArg( - kernel, - arg_index, - arg_size, - arg_value); -} -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clGetKernelInfo( - kernel, - param_name, - param_value_size, - param_value, - param_value_size_ret); +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetExtensionFunctionAddress( + function_name); +#endif // defined(CL_ENABLE_LAYERS) + return clGetExtensionFunctionAddress_body( + function_name); } -CL_API_ENTRY cl_int CL_API_CALL -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 +static inline void* clGetExtensionFunctionAddressForPlatform_body( + cl_platform_id platform, + const char* function_name) { - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clGetKernelArgInfo( - kernel, - arg_indx, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} + void* function_address = NULL; -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clGetKernelWorkGroupInfo( - kernel, - device, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); -// Event Object APIs -CL_API_ENTRY cl_int CL_API_CALL -clWaitForEvents(cl_uint num_events, - const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0 -{ - if (!num_events || !event_list) + // check if this is an ICD-aware extension + function_address = khrIcdGetExtensionFunctionAddress(function_name); + if (function_address) { - return CL_INVALID_VALUE; + return function_address; } - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT); - return event_list[0]->dispatch->clWaitForEvents( - num_events, - event_list); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clGetEventInfo( - event, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clRetainEvent(event); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseEvent(cl_event event) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clReleaseEvent(event); -} - -// Profiling APIs -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clGetEventProfilingInfo( - event, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -// Flush and Finish APIs -CL_API_ENTRY cl_int CL_API_CALL -clFlush(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clFlush(command_queue); -} - -CL_API_ENTRY cl_int CL_API_CALL -clFinish(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clFinish(command_queue); -} - -// Enqueued Commands APIs -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReadBuffer( - command_queue, - buffer, - blocking_read, - offset, - cb, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReadBufferRect( - command_queue, - buffer, - blocking_read, - buffer_origin, - host_origin, - region, - buffer_row_pitch, - buffer_slice_pitch, - host_row_pitch, - host_slice_pitch, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueWriteBuffer( - command_queue, - buffer, - blocking_write, - offset, - cb, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueWriteBufferRect( - command_queue, - buffer, - blocking_read, - buffer_origin, - host_origin, - region, - buffer_row_pitch, - buffer_slice_pitch, - host_row_pitch, - host_slice_pitch, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueFillBuffer( - command_queue, - buffer, - pattern, - pattern_size, - offset, - cb, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueCopyBuffer( - command_queue, - src_buffer, - dst_buffer, - src_offset, - dst_offset, - cb, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueCopyBufferRect( - command_queue, - src_buffer, - dst_buffer, - src_origin, - dst_origin, - region, - src_row_pitch, - src_slice_pitch, - dst_row_pitch, - dst_slice_pitch, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReadImage( - command_queue, - image, - blocking_read, - origin, - region, - row_pitch, - slice_pitch, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueWriteImage( - command_queue, - image, - blocking_write, - origin, - region, - input_row_pitch, - input_slice_pitch, - ptr, - num_events_in_wait_list, - event_wait_list, - event); -} + // This is not an ICD-aware extension, so call into the implementation + // to get the extension function address. -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueFillImage( - command_queue, - image, - fill_color, - origin, - region, - num_events_in_wait_list, - event_wait_list, - event); + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL); + return platform->dispatch->clGetExtensionFunctionAddressForPlatform( + platform, + function_name); } -CL_API_ENTRY cl_int CL_API_CALL -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 +void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_disp( + cl_platform_id platform, + const char* function_name) { - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueCopyImage( - command_queue, - src_image, - dst_image, - src_origin, - dst_origin, - region, - num_events_in_wait_list, - event_wait_list, - event); + return clGetExtensionFunctionAddressForPlatform_body( + platform, + function_name); } -CL_API_ENTRY cl_int CL_API_CALL -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 +CL_API_ENTRY void* CL_API_CALL clGetExtensionFunctionAddressForPlatform( + cl_platform_id platform, + const char* function_name) { - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueCopyImageToBuffer( - command_queue, - src_image, - dst_buffer, - src_origin, - region, - dst_offset, - num_events_in_wait_list, - event_wait_list, - event); + // make sure the ICD is initialized + khrIcdInitialize(); +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetExtensionFunctionAddressForPlatform( + platform, + function_name); +#endif // defined(CL_ENABLE_LAYERS) + return clGetExtensionFunctionAddressForPlatform_body( + platform, + function_name); } -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueCopyBufferToImage( - command_queue, - src_buffer, - dst_image, - src_offset, - dst_origin, - region, - num_events_in_wait_list, - event_wait_list, - event); +#ifdef __cplusplus } - -CL_API_ENTRY void * CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueMapBuffer( - command_queue, - buffer, - blocking_map, - map_flags, - offset, - cb, - num_events_in_wait_list, - event_wait_list, - event, - errcode_ret); -} - -CL_API_ENTRY void * CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueMapImage( - command_queue, - image, - blocking_map, - map_flags, - origin, - region, - image_row_pitch, - image_slice_pitch, - num_events_in_wait_list, - event_wait_list, - event, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueUnmapMemObject( - command_queue, - memobj, - mapped_ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueMigrateMemObjects( - command_queue, - num_mem_objects, - mem_objects, - flags, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueNDRangeKernel( - command_queue, - kernel, - work_dim, - global_work_offset, - global_work_size, - local_work_size, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueTask( - command_queue, - kernel, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueNativeKernel( - command_queue, - user_func, - args, - cb_args, - num_mem_objects, - mem_list, - args_mem_loc, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueMarkerWithWaitList( - command_queue, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueBarrierWithWaitList( - command_queue, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY void * CL_API_CALL -clGetExtensionFunctionAddressForPlatform(cl_platform_id platform, - const char * function_name) CL_API_SUFFIX__VERSION_1_2 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); - - // make sure the ICD is initialized - khrIcdInitialize(); - - // return any ICD-aware extensions - - // Most extensions, including multi-vendor KHR and EXT extensions, - // do not need to be ICD-aware and do not require any ICD loader - // modifications. The KHR and EXT extensions below were added for - // backwards compatibility only. - #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name - - // Functions supporting the creation of OpenCL Memory Objects - // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing) - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects); - - // cl_khr_gl_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR); - - // cl_khr_gl_event - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR); - -#if defined(_WIN32) - // cl_khr_d3d10_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR); - // cl_khr_d3d11_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR); - // cl_khr_dx9_media_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR); #endif - - // cl_ext_device_fission - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT); - - /* cl_khr_egl_image */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR); - - /* cl_khr_egl_event */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR); - - /* cl_khr_sub_groups */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR); - - #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD - - // This is not an ICD-aware extension, so call into the implementation - // to get the extension function address. - - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, NULL); - return platform->dispatch->clGetExtensionFunctionAddressForPlatform( - platform, - function_name); -} - -// Deprecated APIs -CL_API_ENTRY cl_int CL_API_CALL -clSetCommandQueueProperty(cl_command_queue command_queue, - cl_command_queue_properties properties, - cl_bool enable, - cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clSetCommandQueueProperty( - command_queue, - properties, - enable, - old_properties); -} - -CL_API_ENTRY cl_int CL_API_CALL -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) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); - return in_device->dispatch->clCreateSubDevicesEXT( - in_device, - partition_properties, - num_entries, - out_devices, - num_devices); -} - -CL_API_ENTRY cl_int CL_API_CALL -clRetainDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clRetainDeviceEXT(device); -} - -CL_API_ENTRY cl_int CL_API_CALL -clReleaseDeviceEXT(cl_device_id device) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clReleaseDeviceEXT(device); -} - -CL_API_ENTRY cl_mem CL_API_CALL -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_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateImage2D( - context, - flags, - image_format, - image_width, - image_height, - image_row_pitch, - host_ptr, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -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_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateImage3D( - context, - flags, - image_format, - image_width, - image_height, - image_depth, - image_row_pitch, - image_slice_pitch, - host_ptr, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clUnloadCompiler(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - return CL_SUCCESS; -} - -CL_API_ENTRY cl_int CL_API_CALL -clEnqueueMarker(cl_command_queue command_queue, - cl_event * event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueMarker( - command_queue, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -clEnqueueWaitForEvents(cl_command_queue command_queue, - cl_uint num_events, - const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueWaitForEvents( - command_queue, - num_events, - event_list); -} - -CL_API_ENTRY cl_int CL_API_CALL -clEnqueueBarrier(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueBarrier(command_queue); -} - -CL_API_ENTRY void * CL_API_CALL -clGetExtensionFunctionAddress(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED -{ - size_t function_name_length = 0; - KHRicdVendor* vendor = NULL; - - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(function_name, NULL); - - // make sure the ICD is initialized - khrIcdInitialize(); - function_name_length = strlen(function_name); - - // return any ICD-aware extensions - - // Most extensions, including multi-vendor KHR and EXT extensions, - // do not need to be ICD-aware and do not require any ICD loader - // modifications. The KHR and EXT extensions below were added for - // backwards compatibility only. - #define CL_COMMON_EXTENSION_ENTRYPOINT_ADD(name) if (!strcmp(function_name, #name) ) return (void *)(size_t)&name - - // Functions supporting the creation of OpenCL Memory Objects - // from OpenGL Objects (cl_apple_gl_sharing, cl_khr_gl_sharing) - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLBuffer); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture2D); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLTexture3D); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromGLRenderbuffer); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLObjectInfo); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLTextureInfo); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireGLObjects); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseGLObjects); - - // cl_khr_gl_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetGLContextInfoKHR); - - // cl_khr_gl_event - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromGLsyncKHR); - -#if defined(_WIN32) - // cl_khr_d3d10_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D10KHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10BufferKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture2DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D10Texture3DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D10ObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D10ObjectsKHR); - // cl_khr_d3d11_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromD3D11KHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11BufferKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture2DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromD3D11Texture3DKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireD3D11ObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseD3D11ObjectsKHR); - // cl_khr_dx9_media_sharing - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetDeviceIDsFromDX9MediaAdapterKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromDX9MediaSurfaceKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireDX9MediaSurfacesKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseDX9MediaSurfacesKHR); -#endif - - // cl_ext_device_fission - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateSubDevicesEXT); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clRetainDeviceEXT); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clReleaseDeviceEXT); - - /* cl_khr_egl_image */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateFromEGLImageKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueAcquireEGLObjectsKHR); - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clEnqueueReleaseEGLObjectsKHR); - - /* cl_khr_egl_event */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clCreateEventFromEGLSyncKHR); - - /* cl_khr_sub_groups */ - CL_COMMON_EXTENSION_ENTRYPOINT_ADD(clGetKernelSubGroupInfoKHR); - - #undef CL_COMMON_EXTENSION_ENTRYPOINT_ADD - - // fall back to vendor extension detection - for (vendor = khrIcdVendors; vendor; vendor = vendor->next) - { - size_t vendor_suffix_length = strlen(vendor->suffix); - if (vendor_suffix_length <= function_name_length && vendor_suffix_length > 0) - { - const char *function_suffix = function_name+function_name_length-vendor_suffix_length; - if (!strcmp(function_suffix, vendor->suffix) ) - { - return vendor->clGetExtensionFunctionAddress(function_name); - } - } - } - return NULL; -} - -// GL and other APIs -CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( - cl_context context, - cl_mem_flags flags, - cl_GLuint bufobj, - int * errcode_ret) CL_API_SUFFIX__VERSION_1_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromGLBuffer( - context, - flags, - bufobj, - errcode_ret); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromGLTexture( - context, - flags, - target, - miplevel, - texture, - errcode_ret); -} - -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_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromGLTexture2D( - context, - flags, - target, - miplevel, - texture, - errcode_ret); -} - -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_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromGLTexture3D( - context, - flags, - target, - miplevel, - texture, - errcode_ret); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromGLRenderbuffer( - context, - flags, - renderbuffer, - errcode_ret); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clGetGLObjectInfo( - memobj, - gl_object_type, - gl_object_name); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clGetGLTextureInfo( - memobj, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueAcquireGLObjects( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReleaseGLObjects( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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 -{ - cl_platform_id platform = NULL; - - // initialize the platforms (in case they have not been already) - khrIcdInitialize(); - - // determine the platform to use from the properties specified - khrIcdContextPropertiesGetPlatform(properties, &platform); - - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetGLContextInfoKHR( - properties, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateEventFromGLsyncKHR( - context, - sync, - errcode_ret); -} - -#if defined(_WIN32) -/* - * - * cl_d3d10_sharing_khr - * - */ - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetDeviceIDsFromD3D10KHR( - platform, - d3d_device_source, - d3d_object, - d3d_device_set, - num_entries, - devices, - num_devices); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D10BufferKHR( - cl_context context, - cl_mem_flags flags, - ID3D10Buffer *resource, - cl_int *errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D10BufferKHR( - context, - flags, - resource, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D10Texture2DKHR( - cl_context context, - cl_mem_flags flags, - ID3D10Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D10Texture2DKHR( - context, - flags, - resource, - subresource, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D10Texture3DKHR( - cl_context context, - cl_mem_flags flags, - ID3D10Texture3D *resource, - UINT subresource, - cl_int *errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D10Texture3DKHR( - context, - flags, - resource, - subresource, - errcode_ret); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueAcquireD3D10ObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReleaseD3D10ObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -/* - * - * cl_d3d11_sharing_khr - * - */ - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetDeviceIDsFromD3D11KHR( - platform, - d3d_device_source, - d3d_object, - d3d_device_set, - num_entries, - devices, - num_devices); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D11BufferKHR( - cl_context context, - cl_mem_flags flags, - ID3D11Buffer * resource, - cl_int * errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D11BufferKHR( - context, - flags, - resource, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D11Texture2DKHR( - cl_context context, - cl_mem_flags flags, - ID3D11Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D11Texture2DKHR( - context, - flags, - resource, - subresource, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromD3D11Texture3DKHR( - cl_context context, - cl_mem_flags flags, - ID3D11Texture3D * resource, - UINT subresource, - cl_int * errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromD3D11Texture3DKHR( - context, - flags, - resource, - subresource, - errcode_ret); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueAcquireD3D11ObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReleaseD3D11ObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -/* - * - * cl_khr_dx9_media_sharing - * - */ - -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_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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); - return platform->dispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( - platform, - num_media_adapters, - media_adapters_type, - media_adapters, - media_adapter_set, - num_entries, - devices, - num_devices); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromDX9MediaSurfaceKHR( - context, - flags, - adapter_type, - surface_info, - plane, - errcode_ret); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueAcquireDX9MediaSurfacesKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReleaseDX9MediaSurfacesKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -#endif - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clSetEventCallback( - event, - command_exec_callback_type, - pfn_notify, - user_data); -} - -CL_API_ENTRY cl_mem CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT); - return buffer->dispatch->clCreateSubBuffer( - buffer, - flags, - buffer_create_type, - buffer_create_info, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetMemObjectDestructorCallback( - cl_mem memobj, - void (CL_CALLBACK * pfn_notify)( cl_mem, void*), - void * user_data ) CL_API_SUFFIX__VERSION_1_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); - return memobj->dispatch->clSetMemObjectDestructorCallback( - memobj, - pfn_notify, - user_data); -} - -CL_API_ENTRY cl_event CL_API_CALL -clCreateUserEvent( - cl_context context, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateUserEvent( - context, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetUserEventStatus( - cl_event event, - cl_int execution_status) CL_API_SUFFIX__VERSION_1_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); - return event->dispatch->clSetUserEventStatus( - event, - execution_status); -} - -CL_API_ENTRY cl_mem CL_API_CALL -clCreateFromEGLImageKHR( - cl_context context, - CLeglDisplayKHR display, - CLeglImageKHR image, - cl_mem_flags flags, - const cl_egl_image_properties_khr *properties, - cl_int *errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateFromEGLImageKHR( - context, - display, - image, - flags, - properties, - errcode_ret); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueAcquireEGLObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -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) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueReleaseEGLObjectsKHR( - command_queue, - num_objects, - mem_objects, - num_events_in_wait_list, - event_wait_list, - event); -} - -/* cl_khr_egl_event */ -CL_API_ENTRY cl_event CL_API_CALL -clCreateEventFromEGLSyncKHR( - cl_context context, - CLeglSyncKHR sync, - CLeglDisplayKHR display, - cl_int *errcode_ret) -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateEventFromEGLSyncKHR( - context, - sync, - display, - errcode_ret); -} - -CL_API_ENTRY cl_command_queue CL_API_CALL -clCreateCommandQueueWithProperties( - cl_context context, - cl_device_id device, - const cl_queue_properties * properties, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateCommandQueueWithProperties( - context, - device, - properties, - errcode_ret); -} - -CL_API_ENTRY cl_mem CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreatePipe( - context, - flags, - pipe_packet_size, - pipe_max_packets, - properties, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT); - return pipe->dispatch->clGetPipeInfo( - pipe, - param_name, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY void * CL_API_CALL -clSVMAlloc( - cl_context context, - cl_svm_mem_flags flags, - size_t size, - cl_uint alignment) CL_API_SUFFIX__VERSION_2_0 -{ - if (!context) { - return NULL; - } - return context->dispatch->clSVMAlloc( - context, - flags, - size, - alignment); -} - -CL_API_ENTRY void CL_API_CALL -clSVMFree( - cl_context context, - void * svm_pointer) CL_API_SUFFIX__VERSION_2_0 -{ - if (!context || !svm_pointer) { - return; - } - context->dispatch->clSVMFree( - context, - svm_pointer); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMFree( - command_queue, - num_svm_pointers, - svm_pointers, - pfn_free_func, - user_data, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMMemcpy( - command_queue, - blocking_copy, - dst_ptr, - src_ptr, - size, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMMemFill( - command_queue, - svm_ptr, - pattern, - pattern_size, - size, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -clEnqueueSVMMap( - 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_2_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMMap( - command_queue, - blocking_map, - flags, - svm_ptr, - size, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMUnmap( - command_queue, - svm_ptr, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_sampler CL_API_CALL -clCreateSamplerWithProperties( - cl_context context, - const cl_sampler_properties * sampler_properties, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateSamplerWithProperties( - context, - sampler_properties, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetKernelArgSVMPointer( - cl_kernel kernel, - cl_uint arg_index, - const void * arg_value) CL_API_SUFFIX__VERSION_2_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clSetKernelArgSVMPointer( - kernel, - arg_index, - arg_value); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - return kernel->dispatch->clSetKernelExecInfo( - kernel, - param_name, - param_value_size, - param_value); -} - -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_EXT_SUFFIX__VERSION_2_0 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_kernel, CL_INVALID_KERNEL); - return in_kernel->dispatch->clGetKernelSubGroupInfoKHR( - in_kernel, - in_device, - param_name, - input_value_size, - input_value, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -clSetDefaultDeviceCommandQueue( - cl_context context, - cl_device_id device, - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return context->dispatch->clSetDefaultDeviceCommandQueue( - context, - device, - command_queue); -} - -CL_API_ENTRY cl_program CL_API_CALL -clCreateProgramWithIL( - cl_context context, - const void * il, - size_t length, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); - return context->dispatch->clCreateProgramWithIL( - context, - il, - length, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return kernel->dispatch->clGetKernelSubGroupInfo( - kernel, - device, - param_name, - input_value_size, - input_value, - param_value_size, - param_value, - param_value_size_ret); -} - -CL_API_ENTRY cl_kernel CL_API_CALL -clCloneKernel( - cl_kernel source_kernel, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL); - return source_kernel->dispatch->clCloneKernel( - source_kernel, - errcode_ret); -} - -CL_API_ENTRY cl_int CL_API_CALL -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 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); - return command_queue->dispatch->clEnqueueSVMMigrateMem( - command_queue, - num_svm_pointers, - svm_pointers, - sizes, - flags, - num_events_in_wait_list, - event_wait_list, - event); -} - -CL_API_ENTRY cl_int CL_API_CALL -clGetDeviceAndHostTimer( - cl_device_id device, - cl_ulong * device_timestamp, - cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clGetDeviceAndHostTimer( - device, - device_timestamp, - host_timestamp); -} - -CL_API_ENTRY cl_int CL_API_CALL -clGetHostTimer( - cl_device_id device, - cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1 -{ - KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); - return device->dispatch->clGetHostTimer( - device, - host_timestamp); -} - - diff --git a/loader/icd_dispatch.h b/loader/icd_dispatch.h index 22af335..3f0722f 100644 --- a/loader/icd_dispatch.h +++ b/loader/icd_dispatch.h @@ -35,6 +35,14 @@ #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 + // cl.h #include @@ -48,1413 +56,9 @@ #include #endif #include -#include #include #include - -/* - * - * function pointer typedefs - * - */ - -// Platform APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clGetPlatformIDs)( - 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 *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL * KHRpfn_clRetainDevice)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_2; - -typedef CL_API_ENTRY cl_int (CL_API_CALL * KHRpfn_clReleaseDevice)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_2; - -// Context APIs -typedef CL_API_ENTRY cl_context (CL_API_CALL *KHRpfn_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_API_ENTRY cl_context (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainContext)( - cl_context context) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseContext)( - cl_context context) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_command_queue (CL_API_CALL *KHRpfn_clCreateCommandQueue)( - cl_context context, - cl_device_id device, - cl_command_queue_properties properties, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_command_queue (CL_API_CALL *KHRpfn_clCreateCommandQueueWithProperties)( - cl_context /* context */, - cl_device_id /* device */, - const cl_queue_properties * /* properties */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainCommandQueue)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseCommandQueue)( - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateBuffer)( - cl_context context, - cl_mem_flags flags, - size_t size, - void * host_ptr, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainMemObject)(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseMemObject)(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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 CL_API_ENTRY void * (CL_API_CALL *KHRpfn_clSVMAlloc)( - cl_context /* context */, - cl_svm_mem_flags /* flags */, - size_t /* size */, - unsigned int /* alignment */) CL_API_SUFFIX__VERSION_2_0; - -typedef CL_API_ENTRY void (CL_API_CALL *KHRpfn_clSVMFree)( - cl_context /* context */, - void * /* svm_pointer */) CL_API_SUFFIX__VERSION_2_0; - -// Sampler APIs -typedef CL_API_ENTRY cl_sampler (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainSampler)(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseSampler)(cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_sampler (CL_API_CALL *KHRpfn_clCreateSamplerWithProperties)( - cl_context /* context */, - const cl_sampler_properties * /* sampler_properties */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_2_0; - -// Program Object APIs -typedef CL_API_ENTRY cl_program (CL_API_CALL *KHRpfn_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_API_ENTRY cl_program (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_program (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainProgram)(cl_program program) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseProgram)(cl_program program) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_program (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetProgramSpecializationConstant)( - cl_program program, - cl_uint spec_id, - size_t spec_size, - const void* spec_value) CL_API_SUFFIX__VERSION_2_2; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetProgramReleaseCallback)( - cl_program program, - void (CL_CALLBACK * pfn_notify)(cl_program program, void * user_data), - void * user_data) CL_API_SUFFIX__VERSION_2_2; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clUnloadPlatformCompiler)( - cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_kernel (CL_API_CALL *KHRpfn_clCreateKernel)( - cl_program program, - const char * kernel_name, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clCreateKernelsInProgram)( - cl_program program, - cl_uint num_kernels, - cl_kernel * kernels, - cl_uint * num_kernels_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainKernel)(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseKernel)(cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetKernelArg)( - cl_kernel kernel, - cl_uint arg_index, - size_t arg_size, - const void * arg_value) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetKernelArgSVMPointer)( - cl_kernel /* kernel */, - cl_uint /* arg_index */, - const void * /* arg_value */) CL_API_SUFFIX__VERSION_2_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_EXT_SUFFIX__VERSION_2_0; - -// Event Object APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clWaitForEvents)( - cl_uint num_events, - const cl_event * event_list) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clRetainEvent)(cl_event event) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clReleaseEvent)(cl_event event) CL_API_SUFFIX__VERSION_1_0; - -// Profiling APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clFlush)(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clFinish)(cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0; - -// Enqueued Commands APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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 CL_API_ENTRY void * (CL_API_CALL *KHRpfn_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 CL_API_ENTRY void * (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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 CL_API_ENTRY void * (CL_API_CALL *KHRpfn_clGetExtensionFunctionAddressForPlatform)( - cl_platform_id platform, - const char * function_name) CL_API_SUFFIX__VERSION_1_2; - -// Shared Virtual Memory APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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; - -// Deprecated APIs -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetCommandQueueProperty)( - cl_command_queue command_queue, - cl_command_queue_properties properties, - cl_bool enable, - cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clUnloadCompiler)(void) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clEnqueueMarker)( - cl_command_queue command_queue, - cl_event * event) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clEnqueueWaitForEvents)( - cl_command_queue command_queue, - cl_uint num_events, - const cl_event * event_list) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clEnqueueBarrier)(cl_command_queue command_queue) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -typedef CL_API_ENTRY void * (CL_API_CALL *KHRpfn_clGetExtensionFunctionAddress)(const char *function_name) CL_EXT_SUFFIX__VERSION_1_1_DEPRECATED; - -// GL and other APIs -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromGLBuffer)( - cl_context context, - cl_mem_flags flags, - cl_GLuint bufobj, - int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromGLRenderbuffer)( - cl_context context, - cl_mem_flags flags, - cl_GLuint renderbuffer, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clGetGLObjectInfo)( - cl_mem memobj, - cl_gl_object_type * gl_object_type, - cl_GLuint * gl_object_name) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_event (CL_API_CALL *KHRpfn_clCreateEventFromGLsyncKHR)( - cl_context context, - cl_GLsync sync, - cl_int *errcode_ret); - - -#if defined(_WIN32) - -/* cl_khr_d3d10_sharing */ - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D10BufferKHR)( - cl_context context, - cl_mem_flags flags, - ID3D10Buffer * resource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D10Texture2DKHR)( - cl_context context, - cl_mem_flags flags, - ID3D10Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D10Texture3DKHR)( - cl_context context, - cl_mem_flags flags, - ID3D10Texture3D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D11BufferKHR)( - cl_context context, - cl_mem_flags flags, - ID3D11Buffer * resource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D11Texture2DKHR)( - cl_context context, - cl_mem_flags flags, - ID3D11Texture2D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_clCreateFromD3D11Texture3DKHR)( - cl_context context, - cl_mem_flags flags, - ID3D11Texture3D * resource, - UINT subresource, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_1_2; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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 *KHRpfn_clGetDeviceIDsFromD3D10KHR; -typedef void *KHRpfn_clCreateFromD3D10BufferKHR; -typedef void *KHRpfn_clCreateFromD3D10Texture2DKHR; -typedef void *KHRpfn_clCreateFromD3D10Texture3DKHR; -typedef void *KHRpfn_clEnqueueAcquireD3D10ObjectsKHR; -typedef void *KHRpfn_clEnqueueReleaseD3D10ObjectsKHR; - -/* cl_khr_d3d11_sharing */ -typedef void *KHRpfn_clGetDeviceIDsFromD3D11KHR; -typedef void *KHRpfn_clCreateFromD3D11BufferKHR; -typedef void *KHRpfn_clCreateFromD3D11Texture2DKHR; -typedef void *KHRpfn_clCreateFromD3D11Texture3DKHR; -typedef void *KHRpfn_clEnqueueAcquireD3D11ObjectsKHR; -typedef void *KHRpfn_clEnqueueReleaseD3D11ObjectsKHR; - -/* cl_khr_dx9_media_sharing */ -typedef void *KHRpfn_clCreateFromDX9MediaSurfaceKHR; -typedef void *KHRpfn_clEnqueueAcquireDX9MediaSurfacesKHR; -typedef void *KHRpfn_clEnqueueReleaseDX9MediaSurfacesKHR; -typedef void *KHRpfn_clGetDeviceIDsFromDX9MediaAdapterKHR; - -#endif - -/* OpenCL 1.1 */ - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_event (CL_API_CALL *KHRpfn_clCreateUserEvent)( - cl_context /* context */, - cl_int * /* errcode_ret */) CL_API_SUFFIX__VERSION_1_1; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetUserEventStatus)( - cl_event /* event */, - cl_int /* execution_status */) CL_API_SUFFIX__VERSION_1_1; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL * KHRpfn_clRetainDeviceEXT)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_0; - -typedef CL_API_ENTRY cl_int (CL_API_CALL * KHRpfn_clReleaseDeviceEXT)( - cl_device_id device) CL_API_SUFFIX__VERSION_1_0; - -/* cl_khr_egl_image */ -typedef CL_API_ENTRY cl_mem (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_event (CL_API_CALL *KHRpfn_clCreateEventFromEGLSyncKHR)( - cl_context context, - CLeglSyncKHR sync, - CLeglDisplayKHR display, - cl_int *errcode_ret); - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clSetDefaultDeviceCommandQueue)( - cl_context context, - cl_device_id device, - cl_command_queue command_queue) CL_API_SUFFIX__VERSION_2_1; - -typedef CL_API_ENTRY cl_program (CL_API_CALL *KHRpfn_clCreateProgramWithIL)( - cl_context context, - const void * il, - size_t length, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_kernel (CL_API_CALL *KHRpfn_clCloneKernel)( - cl_kernel source_kernel, - cl_int * errcode_ret) CL_API_SUFFIX__VERSION_2_1; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_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_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clGetDeviceAndHostTimer)( - cl_device_id device, - cl_ulong * device_timestamp, - cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1; - -typedef CL_API_ENTRY cl_int (CL_API_CALL *KHRpfn_clGetHostTimer)( - cl_device_id device, - cl_ulong * host_timestamp) CL_API_SUFFIX__VERSION_2_1; - -/* - * - * vendor dispatch table structure - * - * note that the types in the structure KHRicdVendorDispatch mirror the function - * names listed in the string table khrIcdVendorDispatchFunctionNames - * - */ - -typedef struct KHRicdVendorDispatchRec KHRicdVendorDispatch; - -struct KHRicdVendorDispatchRec -{ - /* OpenCL 1.0 */ - KHRpfn_clGetPlatformIDs clGetPlatformIDs; - KHRpfn_clGetPlatformInfo clGetPlatformInfo; - KHRpfn_clGetDeviceIDs clGetDeviceIDs; - KHRpfn_clGetDeviceInfo clGetDeviceInfo; - KHRpfn_clCreateContext clCreateContext; - KHRpfn_clCreateContextFromType clCreateContextFromType; - KHRpfn_clRetainContext clRetainContext; - KHRpfn_clReleaseContext clReleaseContext; - KHRpfn_clGetContextInfo clGetContextInfo; - KHRpfn_clCreateCommandQueue clCreateCommandQueue; - KHRpfn_clRetainCommandQueue clRetainCommandQueue; - KHRpfn_clReleaseCommandQueue clReleaseCommandQueue; - KHRpfn_clGetCommandQueueInfo clGetCommandQueueInfo; - KHRpfn_clSetCommandQueueProperty clSetCommandQueueProperty; - KHRpfn_clCreateBuffer clCreateBuffer; - KHRpfn_clCreateImage2D clCreateImage2D; - KHRpfn_clCreateImage3D clCreateImage3D; - KHRpfn_clRetainMemObject clRetainMemObject; - KHRpfn_clReleaseMemObject clReleaseMemObject; - KHRpfn_clGetSupportedImageFormats clGetSupportedImageFormats; - KHRpfn_clGetMemObjectInfo clGetMemObjectInfo; - KHRpfn_clGetImageInfo clGetImageInfo; - KHRpfn_clCreateSampler clCreateSampler; - KHRpfn_clRetainSampler clRetainSampler; - KHRpfn_clReleaseSampler clReleaseSampler; - KHRpfn_clGetSamplerInfo clGetSamplerInfo; - KHRpfn_clCreateProgramWithSource clCreateProgramWithSource; - KHRpfn_clCreateProgramWithBinary clCreateProgramWithBinary; - KHRpfn_clRetainProgram clRetainProgram; - KHRpfn_clReleaseProgram clReleaseProgram; - KHRpfn_clBuildProgram clBuildProgram; - KHRpfn_clUnloadCompiler clUnloadCompiler; - KHRpfn_clGetProgramInfo clGetProgramInfo; - KHRpfn_clGetProgramBuildInfo clGetProgramBuildInfo; - KHRpfn_clCreateKernel clCreateKernel; - KHRpfn_clCreateKernelsInProgram clCreateKernelsInProgram; - KHRpfn_clRetainKernel clRetainKernel; - KHRpfn_clReleaseKernel clReleaseKernel; - KHRpfn_clSetKernelArg clSetKernelArg; - KHRpfn_clGetKernelInfo clGetKernelInfo; - KHRpfn_clGetKernelWorkGroupInfo clGetKernelWorkGroupInfo; - KHRpfn_clWaitForEvents clWaitForEvents; - KHRpfn_clGetEventInfo clGetEventInfo; - KHRpfn_clRetainEvent clRetainEvent; - KHRpfn_clReleaseEvent clReleaseEvent; - KHRpfn_clGetEventProfilingInfo clGetEventProfilingInfo; - KHRpfn_clFlush clFlush; - KHRpfn_clFinish clFinish; - KHRpfn_clEnqueueReadBuffer clEnqueueReadBuffer; - KHRpfn_clEnqueueWriteBuffer clEnqueueWriteBuffer; - KHRpfn_clEnqueueCopyBuffer clEnqueueCopyBuffer; - KHRpfn_clEnqueueReadImage clEnqueueReadImage; - KHRpfn_clEnqueueWriteImage clEnqueueWriteImage; - KHRpfn_clEnqueueCopyImage clEnqueueCopyImage; - KHRpfn_clEnqueueCopyImageToBuffer clEnqueueCopyImageToBuffer; - KHRpfn_clEnqueueCopyBufferToImage clEnqueueCopyBufferToImage; - KHRpfn_clEnqueueMapBuffer clEnqueueMapBuffer; - KHRpfn_clEnqueueMapImage clEnqueueMapImage; - KHRpfn_clEnqueueUnmapMemObject clEnqueueUnmapMemObject; - KHRpfn_clEnqueueNDRangeKernel clEnqueueNDRangeKernel; - KHRpfn_clEnqueueTask clEnqueueTask; - KHRpfn_clEnqueueNativeKernel clEnqueueNativeKernel; - KHRpfn_clEnqueueMarker clEnqueueMarker; - KHRpfn_clEnqueueWaitForEvents clEnqueueWaitForEvents; - KHRpfn_clEnqueueBarrier clEnqueueBarrier; - KHRpfn_clGetExtensionFunctionAddress clGetExtensionFunctionAddress; - KHRpfn_clCreateFromGLBuffer clCreateFromGLBuffer; - KHRpfn_clCreateFromGLTexture2D clCreateFromGLTexture2D; - KHRpfn_clCreateFromGLTexture3D clCreateFromGLTexture3D; - KHRpfn_clCreateFromGLRenderbuffer clCreateFromGLRenderbuffer; - KHRpfn_clGetGLObjectInfo clGetGLObjectInfo; - KHRpfn_clGetGLTextureInfo clGetGLTextureInfo; - KHRpfn_clEnqueueAcquireGLObjects clEnqueueAcquireGLObjects; - KHRpfn_clEnqueueReleaseGLObjects clEnqueueReleaseGLObjects; - KHRpfn_clGetGLContextInfoKHR clGetGLContextInfoKHR; - - /* cl_khr_d3d10_sharing */ - KHRpfn_clGetDeviceIDsFromD3D10KHR clGetDeviceIDsFromD3D10KHR; - KHRpfn_clCreateFromD3D10BufferKHR clCreateFromD3D10BufferKHR; - KHRpfn_clCreateFromD3D10Texture2DKHR clCreateFromD3D10Texture2DKHR; - KHRpfn_clCreateFromD3D10Texture3DKHR clCreateFromD3D10Texture3DKHR; - KHRpfn_clEnqueueAcquireD3D10ObjectsKHR clEnqueueAcquireD3D10ObjectsKHR; - KHRpfn_clEnqueueReleaseD3D10ObjectsKHR clEnqueueReleaseD3D10ObjectsKHR; - - /* OpenCL 1.1 */ - KHRpfn_clSetEventCallback clSetEventCallback; - KHRpfn_clCreateSubBuffer clCreateSubBuffer; - KHRpfn_clSetMemObjectDestructorCallback clSetMemObjectDestructorCallback; - KHRpfn_clCreateUserEvent clCreateUserEvent; - KHRpfn_clSetUserEventStatus clSetUserEventStatus; - KHRpfn_clEnqueueReadBufferRect clEnqueueReadBufferRect; - KHRpfn_clEnqueueWriteBufferRect clEnqueueWriteBufferRect; - KHRpfn_clEnqueueCopyBufferRect clEnqueueCopyBufferRect; - - /* cl_ext_device_fission */ - KHRpfn_clCreateSubDevicesEXT clCreateSubDevicesEXT; - KHRpfn_clRetainDeviceEXT clRetainDeviceEXT; - KHRpfn_clReleaseDeviceEXT clReleaseDeviceEXT; - - /* cl_khr_gl_event */ - KHRpfn_clCreateEventFromGLsyncKHR clCreateEventFromGLsyncKHR; - - /* OpenCL 1.2 */ - KHRpfn_clCreateSubDevices clCreateSubDevices; - KHRpfn_clRetainDevice clRetainDevice; - KHRpfn_clReleaseDevice clReleaseDevice; - KHRpfn_clCreateImage clCreateImage; - KHRpfn_clCreateProgramWithBuiltInKernels clCreateProgramWithBuiltInKernels; - KHRpfn_clCompileProgram clCompileProgram; - KHRpfn_clLinkProgram clLinkProgram; - KHRpfn_clUnloadPlatformCompiler clUnloadPlatformCompiler; - KHRpfn_clGetKernelArgInfo clGetKernelArgInfo; - KHRpfn_clEnqueueFillBuffer clEnqueueFillBuffer; - KHRpfn_clEnqueueFillImage clEnqueueFillImage; - KHRpfn_clEnqueueMigrateMemObjects clEnqueueMigrateMemObjects; - KHRpfn_clEnqueueMarkerWithWaitList clEnqueueMarkerWithWaitList; - KHRpfn_clEnqueueBarrierWithWaitList clEnqueueBarrierWithWaitList; - KHRpfn_clGetExtensionFunctionAddressForPlatform clGetExtensionFunctionAddressForPlatform; - KHRpfn_clCreateFromGLTexture clCreateFromGLTexture; - - /* cl_khr_d3d11_sharing */ - KHRpfn_clGetDeviceIDsFromD3D11KHR clGetDeviceIDsFromD3D11KHR; - KHRpfn_clCreateFromD3D11BufferKHR clCreateFromD3D11BufferKHR; - KHRpfn_clCreateFromD3D11Texture2DKHR clCreateFromD3D11Texture2DKHR; - KHRpfn_clCreateFromD3D11Texture3DKHR clCreateFromD3D11Texture3DKHR; - KHRpfn_clCreateFromDX9MediaSurfaceKHR clCreateFromDX9MediaSurfaceKHR; - KHRpfn_clEnqueueAcquireD3D11ObjectsKHR clEnqueueAcquireD3D11ObjectsKHR; - KHRpfn_clEnqueueReleaseD3D11ObjectsKHR clEnqueueReleaseD3D11ObjectsKHR; - - /* cl_khr_dx9_media_sharing */ - KHRpfn_clGetDeviceIDsFromDX9MediaAdapterKHR clGetDeviceIDsFromDX9MediaAdapterKHR; - KHRpfn_clEnqueueAcquireDX9MediaSurfacesKHR clEnqueueAcquireDX9MediaSurfacesKHR; - KHRpfn_clEnqueueReleaseDX9MediaSurfacesKHR clEnqueueReleaseDX9MediaSurfacesKHR; - - /* cl_khr_egl_image */ - KHRpfn_clCreateFromEGLImageKHR clCreateFromEGLImageKHR; - KHRpfn_clEnqueueAcquireEGLObjectsKHR clEnqueueAcquireEGLObjectsKHR; - KHRpfn_clEnqueueReleaseEGLObjectsKHR clEnqueueReleaseEGLObjectsKHR; - - /* cl_khr_egl_event */ - KHRpfn_clCreateEventFromEGLSyncKHR clCreateEventFromEGLSyncKHR; - - /* OpenCL 2.0 */ - KHRpfn_clCreateCommandQueueWithProperties clCreateCommandQueueWithProperties; - KHRpfn_clCreatePipe clCreatePipe; - KHRpfn_clGetPipeInfo clGetPipeInfo; - KHRpfn_clSVMAlloc clSVMAlloc; - KHRpfn_clSVMFree clSVMFree; - KHRpfn_clEnqueueSVMFree clEnqueueSVMFree; - KHRpfn_clEnqueueSVMMemcpy clEnqueueSVMMemcpy; - KHRpfn_clEnqueueSVMMemFill clEnqueueSVMMemFill; - KHRpfn_clEnqueueSVMMap clEnqueueSVMMap; - KHRpfn_clEnqueueSVMUnmap clEnqueueSVMUnmap; - KHRpfn_clCreateSamplerWithProperties clCreateSamplerWithProperties; - KHRpfn_clSetKernelArgSVMPointer clSetKernelArgSVMPointer; - KHRpfn_clSetKernelExecInfo clSetKernelExecInfo; - - /* cl_khr_sub_groups */ - KHRpfn_clGetKernelSubGroupInfoKHR clGetKernelSubGroupInfoKHR; - - /* OpenCL 2.1 */ - KHRpfn_clCloneKernel clCloneKernel; - KHRpfn_clCreateProgramWithIL clCreateProgramWithIL; - KHRpfn_clEnqueueSVMMigrateMem clEnqueueSVMMigrateMem; - KHRpfn_clGetDeviceAndHostTimer clGetDeviceAndHostTimer; - KHRpfn_clGetHostTimer clGetHostTimer; - KHRpfn_clGetKernelSubGroupInfo clGetKernelSubGroupInfo; - KHRpfn_clSetDefaultDeviceCommandQueue clSetDefaultDeviceCommandQueue; - - /* OpenCL 2.2 */ - KHRpfn_clSetProgramReleaseCallback clSetProgramReleaseCallback; - KHRpfn_clSetProgramSpecializationConstant clSetProgramSpecializationConstant; -}; +#include /* * @@ -1464,47 +68,47 @@ struct KHRicdVendorDispatchRec struct _cl_platform_id { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_device_id { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_context { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_command_queue { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_mem { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_program { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_kernel { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_event { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; struct _cl_sampler { - KHRicdVendorDispatch *dispatch; + cl_icd_dispatch *dispatch; }; #endif // _ICD_DISPATCH_H_ diff --git a/loader/icd_dispatch_generated.c b/loader/icd_dispatch_generated.c new file mode 100644 index 0000000..3aa788a --- /dev/null +++ b/loader/icd_dispatch_generated.c @@ -0,0 +1,7034 @@ +/* + * 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. + * 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_dispatch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Core APIs: +#if defined(CL_ENABLE_LAYERS) +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, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetPlatformInfo( + platform, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clGetPlatformInfo( + platform, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetPlatformInfo_disp( + cl_platform_id platform, + cl_platform_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clGetPlatformInfo( + platform, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceIDs( + platform, + device_type, + num_entries, + devices, + num_devices); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clGetDeviceIDs( + platform, + device_type, + num_entries, + devices, + num_devices); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetDeviceIDs_disp( + cl_platform_id platform, + cl_device_type device_type, + cl_uint num_entries, + cl_device_id* devices, + cl_uint* num_devices) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clGetDeviceIDs( + platform, + device_type, + num_entries, + devices, + num_devices); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetDeviceInfo( + cl_device_id device, + cl_device_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceInfo( + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetDeviceInfo( + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetDeviceInfo_disp( + cl_device_id device, + cl_device_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetDeviceInfo( + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_context CL_API_CALL clCreateContext( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateContext( + properties, + num_devices, + devices, + pfn_notify, + user_data, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + if (num_devices == 0 || devices == NULL) { + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE); + } + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE); + return devices[0]->dispatch->clCreateContext( + properties, + num_devices, + devices, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_context CL_API_CALL clCreateContext_disp( + 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) +{ + if (num_devices == 0 || devices == NULL) { + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE); + } + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(devices[0], CL_INVALID_DEVICE); + return devices[0]->dispatch->clCreateContext( + properties, + num_devices, + devices, + pfn_notify, + user_data, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_context CL_API_CALL clCreateContextFromType( + 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) +{ + khrIcdInitialize(); +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateContextFromType( + properties, + device_type, + pfn_notify, + user_data, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + cl_platform_id platform = NULL; + khrIcdContextPropertiesGetPlatform(properties, &platform); + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clCreateContextFromType( + properties, + device_type, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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), + void* user_data, + cl_int* errcode_ret) +{ + khrIcdInitialize(); + cl_platform_id platform = NULL; + khrIcdContextPropertiesGetPlatform(properties, &platform); + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clCreateContextFromType( + properties, + device_type, + pfn_notify, + user_data, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainContext( + cl_context context) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainContext( + context); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clRetainContext( + context); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainContext_disp( + cl_context context) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clRetainContext( + context); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseContext( + cl_context context) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseContext( + context); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clReleaseContext( + context); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseContext_disp( + cl_context context) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clReleaseContext( + context); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetContextInfo( + cl_context context, + cl_context_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetContextInfo( + context, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clGetContextInfo( + context, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetContextInfo_disp( + cl_context context, + cl_context_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clGetContextInfo( + context, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainCommandQueue( + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainCommandQueue( + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clRetainCommandQueue( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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); + return command_queue->dispatch->clRetainCommandQueue( + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseCommandQueue( + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseCommandQueue( + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clReleaseCommandQueue( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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); + return command_queue->dispatch->clReleaseCommandQueue( + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetCommandQueueInfo( + command_queue, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clGetCommandQueueInfo( + command_queue, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetCommandQueueInfo_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clGetCommandQueueInfo( + command_queue, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL clCreateBuffer( + cl_context context, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateBuffer( + context, + flags, + size, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateBuffer( + context, + flags, + size, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateBuffer_disp( + cl_context context, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateBuffer( + context, + flags, + size, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject( + cl_mem memobj) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainMemObject( + memobj); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clRetainMemObject( + memobj); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainMemObject_disp( + cl_mem memobj) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clRetainMemObject( + memobj); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseMemObject( + cl_mem memobj) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseMemObject( + memobj); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clReleaseMemObject( + memobj); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseMemObject_disp( + cl_mem memobj) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clReleaseMemObject( + memobj); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetSupportedImageFormats( + context, + flags, + image_type, + num_entries, + image_formats, + num_image_formats); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clGetSupportedImageFormats( + context, + flags, + image_type, + num_entries, + image_formats, + num_image_formats); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetSupportedImageFormats_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clGetSupportedImageFormats( + context, + flags, + image_type, + num_entries, + image_formats, + num_image_formats); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetMemObjectInfo( + cl_mem memobj, + cl_mem_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetMemObjectInfo( + memobj, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clGetMemObjectInfo( + memobj, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetMemObjectInfo_disp( + cl_mem memobj, + cl_mem_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clGetMemObjectInfo( + memobj, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetImageInfo( + cl_mem image, + cl_image_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetImageInfo( + image, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT); + return image->dispatch->clGetImageInfo( + image, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetImageInfo_disp( + cl_mem image, + cl_image_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(image, CL_INVALID_MEM_OBJECT); + return image->dispatch->clGetImageInfo( + image, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainSampler( + cl_sampler sampler) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainSampler( + sampler); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clRetainSampler( + sampler); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainSampler_disp( + cl_sampler sampler) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clRetainSampler( + sampler); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseSampler( + cl_sampler sampler) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseSampler( + sampler); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clReleaseSampler( + sampler); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseSampler_disp( + cl_sampler sampler) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clReleaseSampler( + sampler); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetSamplerInfo( + cl_sampler sampler, + cl_sampler_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetSamplerInfo( + sampler, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clGetSamplerInfo( + sampler, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetSamplerInfo_disp( + cl_sampler sampler, + cl_sampler_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(sampler, CL_INVALID_SAMPLER); + return sampler->dispatch->clGetSamplerInfo( + sampler, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithSource( + cl_context context, + cl_uint count, + const char** strings, + const size_t* lengths, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateProgramWithSource( + context, + count, + strings, + lengths, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithSource( + context, + count, + strings, + lengths, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_program CL_API_CALL clCreateProgramWithSource_disp( + cl_context context, + cl_uint count, + const char** strings, + const size_t* lengths, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithSource( + context, + count, + strings, + lengths, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_program CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateProgramWithBinary( + context, + num_devices, + device_list, + lengths, + binaries, + binary_status, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithBinary( + context, + num_devices, + device_list, + lengths, + binaries, + binary_status, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_program CL_API_CALL clCreateProgramWithBinary_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithBinary( + context, + num_devices, + device_list, + lengths, + binaries, + binary_status, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainProgram( + cl_program program) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainProgram( + program); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clRetainProgram( + program); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainProgram_disp( + cl_program program) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clRetainProgram( + program); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseProgram( + cl_program program) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseProgram( + program); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clReleaseProgram( + program); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseProgram_disp( + cl_program program) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clReleaseProgram( + program); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clBuildProgram( + program, + num_devices, + device_list, + options, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clBuildProgram( + program, + num_devices, + device_list, + options, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clBuildProgram_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clBuildProgram( + program, + num_devices, + device_list, + options, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetProgramInfo( + cl_program program, + cl_program_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetProgramInfo( + program, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clGetProgramInfo( + program, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetProgramInfo_disp( + cl_program program, + cl_program_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clGetProgramInfo( + program, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetProgramBuildInfo( + program, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clGetProgramBuildInfo( + program, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetProgramBuildInfo_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clGetProgramBuildInfo( + program, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_kernel CL_API_CALL clCreateKernel( + cl_program program, + const char* kernel_name, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateKernel( + program, + kernel_name, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM); + return program->dispatch->clCreateKernel( + program, + kernel_name, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_kernel CL_API_CALL clCreateKernel_disp( + cl_program program, + const char* kernel_name, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(program, CL_INVALID_PROGRAM); + return program->dispatch->clCreateKernel( + program, + kernel_name, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clCreateKernelsInProgram( + cl_program program, + cl_uint num_kernels, + cl_kernel* kernels, + cl_uint* num_kernels_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateKernelsInProgram( + program, + num_kernels, + kernels, + num_kernels_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clCreateKernelsInProgram( + program, + num_kernels, + kernels, + num_kernels_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clCreateKernelsInProgram_disp( + cl_program program, + cl_uint num_kernels, + cl_kernel* kernels, + cl_uint* num_kernels_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clCreateKernelsInProgram( + program, + num_kernels, + kernels, + num_kernels_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainKernel( + cl_kernel kernel) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainKernel( + kernel); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clRetainKernel( + kernel); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainKernel_disp( + cl_kernel kernel) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clRetainKernel( + kernel); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseKernel( + cl_kernel kernel) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseKernel( + kernel); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clReleaseKernel( + kernel); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseKernel_disp( + cl_kernel kernel) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clReleaseKernel( + kernel); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetKernelArg( + cl_kernel kernel, + cl_uint arg_index, + size_t arg_size, + const void* arg_value) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetKernelArg( + kernel, + arg_index, + arg_size, + arg_value); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelArg( + kernel, + arg_index, + arg_size, + arg_value); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetKernelArg_disp( + cl_kernel kernel, + cl_uint arg_index, + size_t arg_size, + const void* arg_value) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelArg( + kernel, + arg_index, + arg_size, + arg_value); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetKernelInfo( + cl_kernel kernel, + cl_kernel_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetKernelInfo( + kernel, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelInfo( + kernel, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetKernelInfo_disp( + cl_kernel kernel, + cl_kernel_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelInfo( + kernel, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetKernelWorkGroupInfo( + kernel, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelWorkGroupInfo( + kernel, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetKernelWorkGroupInfo_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelWorkGroupInfo( + kernel, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clWaitForEvents( + cl_uint num_events, + const cl_event* event_list) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clWaitForEvents( + num_events, + event_list); +#endif // defined(CL_ENABLE_LAYERS) + if (num_events == 0 || event_list == NULL) { + return CL_INVALID_VALUE; + } + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT); + return event_list[0]->dispatch->clWaitForEvents( + num_events, + event_list); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clWaitForEvents_disp( + cl_uint num_events, + const cl_event* event_list) +{ + if (num_events == 0 || event_list == NULL) { + return CL_INVALID_VALUE; + } + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event_list[0], CL_INVALID_EVENT); + return event_list[0]->dispatch->clWaitForEvents( + num_events, + event_list); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetEventInfo( + cl_event event, + cl_event_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetEventInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clGetEventInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetEventInfo_disp( + cl_event event, + cl_event_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clGetEventInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainEvent( + cl_event event) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainEvent( + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clRetainEvent( + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainEvent_disp( + cl_event event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clRetainEvent( + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseEvent( + cl_event event) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseEvent( + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clReleaseEvent( + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseEvent_disp( + cl_event event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clReleaseEvent( + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetEventProfilingInfo( + cl_event event, + cl_profiling_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetEventProfilingInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clGetEventProfilingInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetEventProfilingInfo_disp( + cl_event event, + cl_profiling_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clGetEventProfilingInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clFlush( + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clFlush( + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clFlush( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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); + return command_queue->dispatch->clFlush( + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clFinish( + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clFinish( + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clFinish( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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); + return command_queue->dispatch->clFinish( + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueReadBuffer( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReadBuffer( + command_queue, + buffer, + blocking_read, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadBuffer( + command_queue, + buffer, + blocking_read, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReadBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadBuffer( + command_queue, + buffer, + blocking_read, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBuffer( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueWriteBuffer( + command_queue, + buffer, + blocking_write, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteBuffer( + command_queue, + buffer, + blocking_write, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueWriteBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteBuffer( + command_queue, + buffer, + blocking_write, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueCopyBuffer( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueCopyBuffer( + command_queue, + src_buffer, + dst_buffer, + src_offset, + dst_offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBuffer( + command_queue, + src_buffer, + dst_buffer, + src_offset, + dst_offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueCopyBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBuffer( + command_queue, + src_buffer, + dst_buffer, + src_offset, + dst_offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReadImage( + command_queue, + image, + blocking_read, + origin, + region, + row_pitch, + slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadImage( + command_queue, + image, + blocking_read, + origin, + region, + row_pitch, + slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReadImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadImage( + command_queue, + image, + blocking_read, + origin, + region, + row_pitch, + slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueWriteImage( + command_queue, + image, + blocking_write, + origin, + region, + input_row_pitch, + input_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteImage( + command_queue, + image, + blocking_write, + origin, + region, + input_row_pitch, + input_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueWriteImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteImage( + command_queue, + image, + blocking_write, + origin, + region, + input_row_pitch, + input_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueCopyImage( + command_queue, + src_image, + dst_image, + src_origin, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyImage( + command_queue, + src_image, + dst_image, + src_origin, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueCopyImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyImage( + command_queue, + src_image, + dst_image, + src_origin, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueCopyImageToBuffer( + command_queue, + src_image, + dst_buffer, + src_origin, + region, + dst_offset, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyImageToBuffer( + command_queue, + src_image, + dst_buffer, + src_origin, + region, + dst_offset, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueCopyImageToBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyImageToBuffer( + command_queue, + src_image, + dst_buffer, + src_origin, + region, + dst_offset, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueCopyBufferToImage( + command_queue, + src_buffer, + dst_image, + src_offset, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBufferToImage( + command_queue, + src_buffer, + dst_image, + src_offset, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueCopyBufferToImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBufferToImage( + command_queue, + src_buffer, + dst_image, + src_offset, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY void* CL_API_CALL clEnqueueMapBuffer( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueMapBuffer( + command_queue, + buffer, + blocking_map, + map_flags, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMapBuffer( + command_queue, + buffer, + blocking_map, + map_flags, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static void* CL_API_CALL clEnqueueMapBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMapBuffer( + command_queue, + buffer, + blocking_map, + map_flags, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY void* CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueMapImage( + command_queue, + image, + blocking_map, + map_flags, + origin, + region, + image_row_pitch, + image_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMapImage( + command_queue, + image, + blocking_map, + map_flags, + origin, + region, + image_row_pitch, + image_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static void* CL_API_CALL clEnqueueMapImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMapImage( + command_queue, + image, + blocking_map, + map_flags, + origin, + region, + image_row_pitch, + image_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueUnmapMemObject( + command_queue, + memobj, + mapped_ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueUnmapMemObject( + command_queue, + memobj, + mapped_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueUnmapMemObject_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueUnmapMemObject( + command_queue, + memobj, + mapped_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueNDRangeKernel( + command_queue, + kernel, + work_dim, + global_work_offset, + global_work_size, + local_work_size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueNDRangeKernel( + command_queue, + kernel, + work_dim, + global_work_offset, + global_work_size, + local_work_size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueNDRangeKernel_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueNDRangeKernel( + command_queue, + kernel, + work_dim, + global_work_offset, + global_work_size, + local_work_size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueNativeKernel( + command_queue, + user_func, + args, + cb_args, + num_mem_objects, + mem_list, + args_mem_loc, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueNativeKernel( + command_queue, + user_func, + args, + cb_args, + num_mem_objects, + mem_list, + args_mem_loc, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueNativeKernel_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueNativeKernel( + command_queue, + user_func, + args, + cb_args, + num_mem_objects, + mem_list, + args_mem_loc, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty( + cl_command_queue command_queue, + cl_command_queue_properties properties, + cl_bool enable, + cl_command_queue_properties* old_properties) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetCommandQueueProperty( + command_queue, + properties, + enable, + old_properties); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clSetCommandQueueProperty( + command_queue, + properties, + enable, + old_properties); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetCommandQueueProperty_disp( + cl_command_queue command_queue, + cl_command_queue_properties properties, + cl_bool enable, + cl_command_queue_properties* old_properties) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clSetCommandQueueProperty( + command_queue, + properties, + enable, + old_properties); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateImage2D( + context, + flags, + image_format, + image_width, + image_height, + image_row_pitch, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage2D( + context, + flags, + image_format, + image_width, + image_height, + image_row_pitch, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateImage2D_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage2D( + context, + flags, + image_format, + image_width, + image_height, + image_row_pitch, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateImage3D( + context, + flags, + image_format, + image_width, + image_height, + image_depth, + image_row_pitch, + image_slice_pitch, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage3D( + context, + flags, + image_format, + image_width, + image_height, + image_depth, + image_row_pitch, + image_slice_pitch, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateImage3D_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage3D( + context, + flags, + image_format, + image_width, + image_height, + image_depth, + image_row_pitch, + image_slice_pitch, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarker( + cl_command_queue command_queue, + cl_event* event) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueMarker( + command_queue, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMarker( + command_queue, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueMarker_disp( + cl_command_queue command_queue, + cl_event* event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMarker( + command_queue, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueWaitForEvents( + cl_command_queue command_queue, + cl_uint num_events, + const cl_event* event_list) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueWaitForEvents( + command_queue, + num_events, + event_list); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWaitForEvents( + command_queue, + num_events, + event_list); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueWaitForEvents_disp( + cl_command_queue command_queue, + cl_uint num_events, + const cl_event* event_list) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWaitForEvents( + command_queue, + num_events, + event_list); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrier( + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueBarrier( + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueBarrier( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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); + return command_queue->dispatch->clEnqueueBarrier( + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clUnloadCompiler( + void ) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clUnloadCompiler( + ); +#endif // defined(CL_ENABLE_LAYERS) + // Nothing! + return CL_SUCCESS; +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clUnloadCompiler_disp( + void ) +{ + // Nothing! + return CL_SUCCESS; +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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, + cl_command_queue_properties properties, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateCommandQueue( + context, + device, + properties, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateCommandQueue( + context, + device, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_command_queue CL_API_CALL clCreateCommandQueue_disp( + cl_context context, + cl_device_id device, + cl_command_queue_properties properties, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateCommandQueue( + context, + device, + properties, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_sampler CL_API_CALL clCreateSampler( + cl_context context, + cl_bool normalized_coords, + cl_addressing_mode addressing_mode, + cl_filter_mode filter_mode, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateSampler( + context, + normalized_coords, + addressing_mode, + filter_mode, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateSampler( + context, + normalized_coords, + addressing_mode, + filter_mode, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_sampler CL_API_CALL clCreateSampler_disp( + cl_context context, + cl_bool normalized_coords, + cl_addressing_mode addressing_mode, + cl_filter_mode filter_mode, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateSampler( + context, + normalized_coords, + addressing_mode, + filter_mode, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueTask( + command_queue, + kernel, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueTask( + command_queue, + kernel, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueTask_disp( + cl_command_queue command_queue, + cl_kernel kernel, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueTask( + command_queue, + kernel, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL clCreateSubBuffer( + cl_mem buffer, + cl_mem_flags flags, + cl_buffer_create_type buffer_create_type, + const void* buffer_create_info, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateSubBuffer( + buffer, + flags, + buffer_create_type, + buffer_create_info, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT); + return buffer->dispatch->clCreateSubBuffer( + buffer, + flags, + buffer_create_type, + buffer_create_info, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateSubBuffer_disp( + cl_mem buffer, + cl_mem_flags flags, + cl_buffer_create_type buffer_create_type, + const void* buffer_create_info, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(buffer, CL_INVALID_MEM_OBJECT); + return buffer->dispatch->clCreateSubBuffer( + buffer, + flags, + buffer_create_type, + buffer_create_info, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetMemObjectDestructorCallback( + cl_mem memobj, + void (CL_CALLBACK* pfn_notify)(cl_mem memobj, void* user_data), + void* user_data) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetMemObjectDestructorCallback( + memobj, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clSetMemObjectDestructorCallback( + memobj, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(memobj, CL_INVALID_MEM_OBJECT); + return memobj->dispatch->clSetMemObjectDestructorCallback( + memobj, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_event CL_API_CALL clCreateUserEvent( + cl_context context, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateUserEvent( + context, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateUserEvent( + context, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_event CL_API_CALL clCreateUserEvent_disp( + cl_context context, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateUserEvent( + context, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetUserEventStatus( + cl_event event, + cl_int execution_status) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetUserEventStatus( + event, + execution_status); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clSetUserEventStatus( + event, + execution_status); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetUserEventStatus_disp( + cl_event event, + cl_int execution_status) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clSetUserEventStatus( + event, + execution_status); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetEventCallback( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetEventCallback( + event, + command_exec_callback_type, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clSetEventCallback( + event, + command_exec_callback_type, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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), + void* user_data) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(event, CL_INVALID_EVENT); + return event->dispatch->clSetEventCallback( + event, + command_exec_callback_type, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReadBufferRect( + command_queue, + buffer, + blocking_read, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadBufferRect( + command_queue, + buffer, + blocking_read, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReadBufferRect_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueReadBufferRect( + command_queue, + buffer, + blocking_read, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueWriteBufferRect( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueWriteBufferRect( + command_queue, + buffer, + blocking_write, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteBufferRect( + command_queue, + buffer, + blocking_write, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueWriteBufferRect_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueWriteBufferRect( + command_queue, + buffer, + blocking_write, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueCopyBufferRect( + command_queue, + src_buffer, + dst_buffer, + src_origin, + dst_origin, + region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBufferRect( + command_queue, + src_buffer, + dst_buffer, + src_origin, + dst_origin, + region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueCopyBufferRect_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueCopyBufferRect( + command_queue, + src_buffer, + dst_buffer, + src_origin, + dst_origin, + region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clCreateSubDevices( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateSubDevices( + in_device, + properties, + num_devices, + out_devices, + num_devices_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); + return in_device->dispatch->clCreateSubDevices( + in_device, + properties, + num_devices, + out_devices, + num_devices_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clCreateSubDevices_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(in_device, CL_INVALID_DEVICE); + return in_device->dispatch->clCreateSubDevices( + in_device, + properties, + num_devices, + out_devices, + num_devices_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clRetainDevice( + cl_device_id device) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clRetainDevice( + device); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clRetainDevice( + device); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clRetainDevice_disp( + cl_device_id device) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clRetainDevice( + device); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clReleaseDevice( + cl_device_id device) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clReleaseDevice( + device); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clReleaseDevice( + device); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clReleaseDevice_disp( + cl_device_id device) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clReleaseDevice( + device); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateImage( + context, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage( + context, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImage( + context, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithBuiltInKernels( + cl_context context, + cl_uint num_devices, + const cl_device_id* device_list, + const char* kernel_names, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateProgramWithBuiltInKernels( + context, + num_devices, + device_list, + kernel_names, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithBuiltInKernels( + context, + num_devices, + device_list, + kernel_names, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_disp( + cl_context context, + cl_uint num_devices, + const cl_device_id* device_list, + const char* kernel_names, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithBuiltInKernels( + context, + num_devices, + device_list, + kernel_names, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCompileProgram( + program, + num_devices, + device_list, + options, + num_input_headers, + input_headers, + header_include_names, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clCompileProgram( + program, + num_devices, + device_list, + options, + num_input_headers, + input_headers, + header_include_names, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clCompileProgram_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clCompileProgram( + program, + num_devices, + device_list, + options, + num_input_headers, + input_headers, + header_include_names, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_program CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clLinkProgram( + context, + num_devices, + device_list, + options, + num_input_programs, + input_programs, + pfn_notify, + user_data, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clLinkProgram( + context, + num_devices, + device_list, + options, + num_input_programs, + input_programs, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_program CL_API_CALL clLinkProgram_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clLinkProgram( + context, + num_devices, + device_list, + options, + num_input_programs, + input_programs, + pfn_notify, + user_data, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clUnloadPlatformCompiler( + cl_platform_id platform) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clUnloadPlatformCompiler( + platform); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clUnloadPlatformCompiler( + platform); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clUnloadPlatformCompiler_disp( + cl_platform_id platform) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(platform, CL_INVALID_PLATFORM); + return platform->dispatch->clUnloadPlatformCompiler( + platform); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetKernelArgInfo( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetKernelArgInfo( + kernel, + arg_index, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelArgInfo( + kernel, + arg_index, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetKernelArgInfo_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelArgInfo( + kernel, + arg_index, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillBuffer( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueFillBuffer( + command_queue, + buffer, + pattern, + pattern_size, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueFillBuffer( + command_queue, + buffer, + pattern, + pattern_size, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueFillBuffer_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueFillBuffer( + command_queue, + buffer, + pattern, + pattern_size, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueFillImage( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueFillImage( + command_queue, + image, + fill_color, + origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueFillImage( + command_queue, + image, + fill_color, + origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueFillImage_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueFillImage( + command_queue, + image, + fill_color, + origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueMigrateMemObjects( + command_queue, + num_mem_objects, + mem_objects, + flags, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMigrateMemObjects( + command_queue, + num_mem_objects, + mem_objects, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueMigrateMemObjects_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMigrateMemObjects( + command_queue, + num_mem_objects, + mem_objects, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueMarkerWithWaitList( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueMarkerWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMarkerWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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, + cl_event* event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueMarkerWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueBarrierWithWaitList( + cl_command_queue command_queue, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueBarrierWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueBarrierWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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, + cl_event* event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueBarrierWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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, + const cl_queue_properties* properties, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateCommandQueueWithProperties( + context, + device, + properties, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateCommandQueueWithProperties( + context, + device, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_disp( + cl_context context, + cl_device_id device, + const cl_queue_properties* properties, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateCommandQueueWithProperties( + context, + device, + properties, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreatePipe( + context, + flags, + pipe_packet_size, + pipe_max_packets, + properties, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreatePipe( + context, + flags, + pipe_packet_size, + pipe_max_packets, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreatePipe_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreatePipe( + context, + flags, + pipe_packet_size, + pipe_max_packets, + properties, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetPipeInfo( + cl_mem pipe, + cl_pipe_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetPipeInfo( + pipe, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT); + return pipe->dispatch->clGetPipeInfo( + pipe, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetPipeInfo_disp( + cl_mem pipe, + cl_pipe_info param_name, + size_t param_value_size, + void* param_value, + size_t* param_value_size_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(pipe, CL_INVALID_MEM_OBJECT); + return pipe->dispatch->clGetPipeInfo( + pipe, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY void* CL_API_CALL clSVMAlloc( + cl_context context, + cl_svm_mem_flags flags, + size_t size, + cl_uint alignment) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSVMAlloc( + context, + flags, + size, + alignment); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL); + return context->dispatch->clSVMAlloc( + context, + flags, + size, + alignment); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static void* CL_API_CALL clSVMAlloc_disp( + cl_context context, + cl_svm_mem_flags flags, + size_t size, + cl_uint alignment) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, NULL); + return context->dispatch->clSVMAlloc( + context, + flags, + size, + alignment); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY void CL_API_CALL clSVMFree( + cl_context context, + void* svm_pointer) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + { + khrFirstLayer->dispatch.clSVMFree( + context, + svm_pointer); + } + else +#endif // defined(CL_ENABLE_LAYERS) + if (context != NULL) + context->dispatch->clSVMFree( + context, + svm_pointer); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static void CL_API_CALL clSVMFree_disp( + cl_context context, + void* svm_pointer) +{ + if (context != NULL) + context->dispatch->clSVMFree( + context, + svm_pointer); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_sampler CL_API_CALL clCreateSamplerWithProperties( + cl_context context, + const cl_sampler_properties* sampler_properties, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateSamplerWithProperties( + context, + sampler_properties, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateSamplerWithProperties( + context, + sampler_properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_sampler CL_API_CALL clCreateSamplerWithProperties_disp( + cl_context context, + const cl_sampler_properties* sampler_properties, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateSamplerWithProperties( + context, + sampler_properties, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetKernelArgSVMPointer( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetKernelArgSVMPointer( + kernel, + arg_index, + arg_value); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelArgSVMPointer( + kernel, + arg_index, + arg_value); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetKernelArgSVMPointer_disp( + cl_kernel kernel, + cl_uint arg_index, + const void* arg_value) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelArgSVMPointer( + kernel, + arg_index, + arg_value); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetKernelExecInfo( + cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void* param_value) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetKernelExecInfo( + kernel, + param_name, + param_value_size, + param_value); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelExecInfo( + kernel, + param_name, + param_value_size, + param_value); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetKernelExecInfo_disp( + cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void* param_value) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clSetKernelExecInfo( + kernel, + param_name, + param_value_size, + param_value); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMFree( + command_queue, + num_svm_pointers, + svm_pointers, + pfn_free_func, + user_data, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMFree( + command_queue, + num_svm_pointers, + svm_pointers, + pfn_free_func, + user_data, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMFree_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMFree( + command_queue, + num_svm_pointers, + svm_pointers, + pfn_free_func, + user_data, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMMemcpy( + command_queue, + blocking_copy, + dst_ptr, + src_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMemcpy( + command_queue, + blocking_copy, + dst_ptr, + src_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMMemcpy_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMemcpy( + command_queue, + blocking_copy, + dst_ptr, + src_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMMemFill( + command_queue, + svm_ptr, + pattern, + pattern_size, + size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMemFill( + command_queue, + svm_ptr, + pattern, + pattern_size, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMMemFill_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMemFill( + command_queue, + svm_ptr, + pattern, + pattern_size, + size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clEnqueueSVMMap( + 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMMap( + command_queue, + blocking_map, + flags, + svm_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMap( + command_queue, + blocking_map, + flags, + svm_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMMap_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMap( + command_queue, + blocking_map, + flags, + svm_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMUnmap( + command_queue, + svm_ptr, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMUnmap( + command_queue, + svm_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMUnmap_disp( + cl_command_queue command_queue, + void* svm_ptr, + cl_uint num_events_in_wait_list, + const cl_event* event_wait_list, + cl_event* event) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMUnmap( + command_queue, + svm_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetDefaultDeviceCommandQueue( + cl_context context, + cl_device_id device, + cl_command_queue command_queue) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetDefaultDeviceCommandQueue( + context, + device, + command_queue); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clSetDefaultDeviceCommandQueue( + context, + device, + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetDefaultDeviceCommandQueue_disp( + cl_context context, + cl_device_id device, + cl_command_queue command_queue) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clSetDefaultDeviceCommandQueue( + context, + device, + command_queue); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetDeviceAndHostTimer( + cl_device_id device, + cl_ulong* device_timestamp, + cl_ulong* host_timestamp) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceAndHostTimer( + device, + device_timestamp, + host_timestamp); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetDeviceAndHostTimer( + device, + device_timestamp, + host_timestamp); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetDeviceAndHostTimer_disp( + cl_device_id device, + cl_ulong* device_timestamp, + cl_ulong* host_timestamp) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetDeviceAndHostTimer( + device, + device_timestamp, + host_timestamp); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clGetHostTimer( + cl_device_id device, + cl_ulong* host_timestamp) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetHostTimer( + device, + host_timestamp); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetHostTimer( + device, + host_timestamp); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetHostTimer_disp( + cl_device_id device, + cl_ulong* host_timestamp) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(device, CL_INVALID_DEVICE); + return device->dispatch->clGetHostTimer( + device, + host_timestamp); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_program CL_API_CALL clCreateProgramWithIL( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateProgramWithIL( + context, + il, + length, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithIL( + context, + il, + length, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_program CL_API_CALL clCreateProgramWithIL_disp( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateProgramWithIL( + context, + il, + length, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_kernel CL_API_CALL clCloneKernel( + cl_kernel source_kernel, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCloneKernel( + source_kernel, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL); + return source_kernel->dispatch->clCloneKernel( + source_kernel, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_kernel CL_API_CALL clCloneKernel_disp( + cl_kernel source_kernel, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(source_kernel, CL_INVALID_KERNEL); + return source_kernel->dispatch->clCloneKernel( + source_kernel, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetKernelSubGroupInfo( + kernel, + device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelSubGroupInfo( + kernel, + device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetKernelSubGroupInfo_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(kernel, CL_INVALID_KERNEL); + return kernel->dispatch->clGetKernelSubGroupInfo( + kernel, + device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueSVMMigrateMem( + command_queue, + num_svm_pointers, + svm_pointers, + sizes, + flags, + num_events_in_wait_list, + event_wait_list, + event); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMigrateMem( + command_queue, + num_svm_pointers, + svm_pointers, + sizes, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueSVMMigrateMem_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(command_queue, CL_INVALID_COMMAND_QUEUE); + return command_queue->dispatch->clEnqueueSVMMigrateMem( + command_queue, + num_svm_pointers, + svm_pointers, + sizes, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetProgramSpecializationConstant( + cl_program program, + cl_uint spec_id, + size_t spec_size, + const void* spec_value) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetProgramSpecializationConstant( + program, + spec_id, + spec_size, + spec_value); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clSetProgramSpecializationConstant( + program, + spec_id, + spec_size, + spec_value); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clSetProgramSpecializationConstant_disp( + cl_program program, + cl_uint spec_id, + size_t spec_size, + const void* spec_value) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clSetProgramSpecializationConstant( + program, + spec_id, + spec_size, + spec_value); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetProgramReleaseCallback( + cl_program program, + void (CL_CALLBACK* pfn_notify)(cl_program program, void* user_data), + void* user_data) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetProgramReleaseCallback( + program, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clSetProgramReleaseCallback( + program, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(program, CL_INVALID_PROGRAM); + return program->dispatch->clSetProgramReleaseCallback( + program, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_int CL_API_CALL clSetContextDestructorCallback( + cl_context context, + void (CL_CALLBACK* pfn_notify)(cl_context context, void* user_data), + void* user_data) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clSetContextDestructorCallback( + context, + pfn_notify, + user_data); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clSetContextDestructorCallback( + context, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(context, CL_INVALID_CONTEXT); + return context->dispatch->clSetContextDestructorCallback( + context, + pfn_notify, + user_data); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL clCreateBufferWithProperties( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateBufferWithProperties( + context, + properties, + flags, + size, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateBufferWithProperties( + context, + properties, + flags, + size, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateBufferWithProperties_disp( + cl_context context, + const cl_mem_properties* properties, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateBufferWithProperties( + context, + properties, + flags, + size, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +CL_API_ENTRY cl_mem CL_API_CALL 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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateImageWithProperties( + context, + properties, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +#endif // defined(CL_ENABLE_LAYERS) + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImageWithProperties( + context, + properties, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateImageWithProperties_disp( + 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) +{ + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(context, CL_INVALID_CONTEXT); + return context->dispatch->clCreateImageWithProperties( + context, + properties, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_ext_device_fission + +CL_API_ENTRY cl_int CL_API_CALL clReleaseDeviceEXT( + cl_device_id device) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.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_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); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_int CL_API_CALL clRetainDeviceEXT( + cl_device_id device) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.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_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); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateSubDevicesEXT( + in_device, + properties, + num_entries, + out_devices, + 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, + num_entries, + out_devices, + num_devices); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clCreateSubDevicesEXT_disp( + 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) +{ + 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, + num_entries, + out_devices, + num_devices); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_d3d10_sharing + +#if defined(_WIN32) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D10KHR( + platform, + d3d_device_source, + d3d_object, + d3d_device_set, + num_entries, + devices, + 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, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_disp( + 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) +{ + 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, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10BufferKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Buffer* resource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D10BufferKHR( + context, + flags, + resource, + 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, + resource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +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, + resource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D10Texture2DKHR( + context, + flags, + resource, + subresource, + 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, + resource, + subresource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_disp( + cl_context context, + cl_mem_flags flags, + ID3D10Texture2D* resource, + UINT subresource, + 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, + resource, + subresource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR( + cl_context context, + cl_mem_flags flags, + ID3D10Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D10Texture3DKHR( + context, + flags, + resource, + subresource, + 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, + resource, + subresource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_disp( + cl_context context, + cl_mem_flags flags, + ID3D10Texture3D* resource, + UINT subresource, + 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, + resource, + subresource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueAcquireD3D10ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReleaseD3D10ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_d3d11_sharing + +#if defined(_WIN32) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceIDsFromD3D11KHR( + platform, + d3d_device_source, + d3d_object, + d3d_device_set, + num_entries, + devices, + 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, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_disp( + 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) +{ + 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, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11BufferKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Buffer* resource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D11BufferKHR( + context, + flags, + resource, + 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, + resource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +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, + resource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D11Texture2DKHR( + context, + flags, + resource, + subresource, + 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, + resource, + subresource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_disp( + cl_context context, + cl_mem_flags flags, + ID3D11Texture2D* resource, + UINT subresource, + 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, + resource, + subresource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR( + cl_context context, + cl_mem_flags flags, + ID3D11Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromD3D11Texture3DKHR( + context, + flags, + resource, + subresource, + 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, + resource, + subresource, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_disp( + cl_context context, + cl_mem_flags flags, + ID3D11Texture3D* resource, + UINT subresource, + 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, + resource, + subresource, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueAcquireD3D11ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReleaseD3D11ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_dx9_media_sharing + +#if defined(_WIN32) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR( + platform, + num_media_adapters, + media_adapter_type, + media_adapters, + media_adapter_set, + num_entries, + devices, + 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, + media_adapter_type, + media_adapters, + media_adapter_set, + num_entries, + devices, + num_devices); +} +#if defined(CL_ENABLE_LAYERS) +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, + void* media_adapters, + cl_dx9_media_adapter_set_khr media_adapter_set, + cl_uint num_entries, + cl_device_id* devices, + 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, + media_adapter_type, + media_adapters, + media_adapter_set, + num_entries, + devices, + num_devices); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromDX9MediaSurfaceKHR( + context, + flags, + adapter_type, + surface_info, + plane, + 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, + adapter_type, + surface_info, + plane, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_disp( + 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) +{ + 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, + adapter_type, + surface_info, + plane, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueAcquireDX9MediaSurfacesKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReleaseDX9MediaSurfacesKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_egl_event + +CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromEGLSyncKHR( + cl_context context, + CLeglSyncKHR sync, + CLeglDisplayKHR display, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateEventFromEGLSyncKHR( + context, + sync, + display, + 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, + display, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +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, + display, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_egl_image + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromEGLImageKHR( + context, + egldisplay, + eglimage, + flags, + properties, + 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, + eglimage, + flags, + properties, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromEGLImageKHR_disp( + cl_context context, + CLeglDisplayKHR egldisplay, + CLeglImageKHR eglimage, + cl_mem_flags flags, + const cl_egl_image_properties_khr* properties, + 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, + eglimage, + flags, + properties, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueAcquireEGLObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReleaseEGLObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_gl_event + +CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR( + cl_context context, + cl_GLsync sync, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateEventFromGLsyncKHR( + context, + sync, + 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_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, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_gl_sharing + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetGLContextInfoKHR( + properties, + param_name, + param_value_size, + param_value, + param_value_size_ret); +#endif // defined(CL_ENABLE_LAYERS) + 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, + param_value_size, + param_value, + param_value_size_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetGLContextInfoKHR_disp( + 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_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, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLBuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromGLBuffer( + context, + flags, + bufobj, + 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, + bufobj, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromGLBuffer_disp( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + 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, + bufobj, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromGLTexture( + context, + flags, + target, + miplevel, + texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromGLTexture_disp( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_mem CL_API_CALL clCreateFromGLRenderbuffer( + cl_context context, + cl_mem_flags flags, + cl_GLuint renderbuffer, + cl_int* errcode_ret) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromGLRenderbuffer( + context, + flags, + renderbuffer, + 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, + renderbuffer, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +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, + renderbuffer, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +CL_API_ENTRY cl_int CL_API_CALL clGetGLObjectInfo( + cl_mem memobj, + cl_gl_object_type* gl_object_type, + cl_GLuint* gl_object_name) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetGLObjectInfo( + memobj, + gl_object_type, + 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_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, + gl_object_name); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetGLTextureInfo( + memobj, + param_name, + param_value_size, + param_value, + 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, + param_value_size, + param_value, + param_value_size_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetGLTextureInfo_disp( + cl_mem memobj, + cl_gl_texture_info param_name, + size_t param_value_size, + void* param_value, + 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, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueAcquireGLObjects( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueAcquireGLObjects_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clEnqueueReleaseGLObjects( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clEnqueueReleaseGLObjects_disp( + 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) +{ + 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, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromGLTexture2D( + context, + flags, + target, + miplevel, + texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromGLTexture2D_disp( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clCreateFromGLTexture3D( + context, + flags, + target, + miplevel, + texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_mem CL_API_CALL clCreateFromGLTexture3D_disp( + cl_context context, + cl_mem_flags flags, + cl_GLenum target, + cl_GLint miplevel, + cl_GLuint texture, + 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, + target, + miplevel, + texture, + errcode_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_subgroups + +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) +{ +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.clGetKernelSubGroupInfoKHR( + in_kernel, + in_device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + 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, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} +#if defined(CL_ENABLE_LAYERS) +static cl_int CL_API_CALL clGetKernelSubGroupInfoKHR_disp( + 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) +{ + 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, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} +#endif // defined(CL_ENABLE_LAYERS) + +/////////////////////////////////////////////////////////////////////////////// + +#if defined(CL_ENABLE_LAYERS) +struct _cl_icd_dispatch khrMasterDispatch = { + &clGetPlatformIDs_disp, + &clGetPlatformInfo_disp, + &clGetDeviceIDs_disp, + &clGetDeviceInfo_disp, + &clCreateContext_disp, + &clCreateContextFromType_disp, + &clRetainContext_disp, + &clReleaseContext_disp, + &clGetContextInfo_disp, + &clCreateCommandQueue_disp, + &clRetainCommandQueue_disp, + &clReleaseCommandQueue_disp, + &clGetCommandQueueInfo_disp, + &clSetCommandQueueProperty_disp, + &clCreateBuffer_disp, + &clCreateImage2D_disp, + &clCreateImage3D_disp, + &clRetainMemObject_disp, + &clReleaseMemObject_disp, + &clGetSupportedImageFormats_disp, + &clGetMemObjectInfo_disp, + &clGetImageInfo_disp, + &clCreateSampler_disp, + &clRetainSampler_disp, + &clReleaseSampler_disp, + &clGetSamplerInfo_disp, + &clCreateProgramWithSource_disp, + &clCreateProgramWithBinary_disp, + &clRetainProgram_disp, + &clReleaseProgram_disp, + &clBuildProgram_disp, + &clUnloadCompiler_disp, + &clGetProgramInfo_disp, + &clGetProgramBuildInfo_disp, + &clCreateKernel_disp, + &clCreateKernelsInProgram_disp, + &clRetainKernel_disp, + &clReleaseKernel_disp, + &clSetKernelArg_disp, + &clGetKernelInfo_disp, + &clGetKernelWorkGroupInfo_disp, + &clWaitForEvents_disp, + &clGetEventInfo_disp, + &clRetainEvent_disp, + &clReleaseEvent_disp, + &clGetEventProfilingInfo_disp, + &clFlush_disp, + &clFinish_disp, + &clEnqueueReadBuffer_disp, + &clEnqueueWriteBuffer_disp, + &clEnqueueCopyBuffer_disp, + &clEnqueueReadImage_disp, + &clEnqueueWriteImage_disp, + &clEnqueueCopyImage_disp, + &clEnqueueCopyImageToBuffer_disp, + &clEnqueueCopyBufferToImage_disp, + &clEnqueueMapBuffer_disp, + &clEnqueueMapImage_disp, + &clEnqueueUnmapMemObject_disp, + &clEnqueueNDRangeKernel_disp, + &clEnqueueTask_disp, + &clEnqueueNativeKernel_disp, + &clEnqueueMarker_disp, + &clEnqueueWaitForEvents_disp, + &clEnqueueBarrier_disp, + &clGetExtensionFunctionAddress_disp, + &clCreateFromGLBuffer_disp, + &clCreateFromGLTexture2D_disp, + &clCreateFromGLTexture3D_disp, + &clCreateFromGLRenderbuffer_disp, + &clGetGLObjectInfo_disp, + &clGetGLTextureInfo_disp, + &clEnqueueAcquireGLObjects_disp, + &clEnqueueReleaseGLObjects_disp, + &clGetGLContextInfoKHR_disp, + + /* cl_khr_d3d10_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromD3D10KHR_disp, + &clCreateFromD3D10BufferKHR_disp, + &clCreateFromD3D10Texture2DKHR_disp, + &clCreateFromD3D10Texture3DKHR_disp, + &clEnqueueAcquireD3D10ObjectsKHR_disp, + &clEnqueueReleaseD3D10ObjectsKHR_disp, +#else + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, +#endif + + /* OpenCL 1.1 */ + &clSetEventCallback_disp, + &clCreateSubBuffer_disp, + &clSetMemObjectDestructorCallback_disp, + &clCreateUserEvent_disp, + &clSetUserEventStatus_disp, + &clEnqueueReadBufferRect_disp, + &clEnqueueWriteBufferRect_disp, + &clEnqueueCopyBufferRect_disp, + + /* cl_ext_device_fission */ + &clCreateSubDevicesEXT_disp, + &clRetainDeviceEXT_disp, + &clReleaseDeviceEXT_disp, + + /* cl_khr_gl_event */ + &clCreateEventFromGLsyncKHR_disp, + + /* OpenCL 1.2 */ + &clCreateSubDevices_disp, + &clRetainDevice_disp, + &clReleaseDevice_disp, + &clCreateImage_disp, + &clCreateProgramWithBuiltInKernels_disp, + &clCompileProgram_disp, + &clLinkProgram_disp, + &clUnloadPlatformCompiler_disp, + &clGetKernelArgInfo_disp, + &clEnqueueFillBuffer_disp, + &clEnqueueFillImage_disp, + &clEnqueueMigrateMemObjects_disp, + &clEnqueueMarkerWithWaitList_disp, + &clEnqueueBarrierWithWaitList_disp, + &clGetExtensionFunctionAddressForPlatform_disp, + &clCreateFromGLTexture_disp, + + /* cl_khr_d3d11_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromD3D11KHR_disp, + &clCreateFromD3D11BufferKHR_disp, + &clCreateFromD3D11Texture2DKHR_disp, + &clCreateFromD3D11Texture3DKHR_disp, + &clCreateFromDX9MediaSurfaceKHR_disp, + &clEnqueueAcquireD3D11ObjectsKHR_disp, + &clEnqueueReleaseD3D11ObjectsKHR_disp, +#else + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, +#endif + + /* cl_khr_dx9_media_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromDX9MediaAdapterKHR_disp, + &clEnqueueAcquireDX9MediaSurfacesKHR_disp, + &clEnqueueReleaseDX9MediaSurfacesKHR_disp, +#else + NULL, + NULL, + NULL, +#endif + + /* cl_khr_egl_image */ + &clCreateFromEGLImageKHR_disp, + &clEnqueueAcquireEGLObjectsKHR_disp, + &clEnqueueReleaseEGLObjectsKHR_disp, + + /* cl_khr_egl_event */ + &clCreateEventFromEGLSyncKHR_disp, + + /* OpenCL 2.0 */ + &clCreateCommandQueueWithProperties_disp, + &clCreatePipe_disp, + &clGetPipeInfo_disp, + &clSVMAlloc_disp, + &clSVMFree_disp, + &clEnqueueSVMFree_disp, + &clEnqueueSVMMemcpy_disp, + &clEnqueueSVMMemFill_disp, + &clEnqueueSVMMap_disp, + &clEnqueueSVMUnmap_disp, + &clCreateSamplerWithProperties_disp, + &clSetKernelArgSVMPointer_disp, + &clSetKernelExecInfo_disp, + + /* cl_khr_sub_groups */ + &clGetKernelSubGroupInfoKHR_disp, + + /* OpenCL 2.1 */ + &clCloneKernel_disp, + &clCreateProgramWithIL_disp, + &clEnqueueSVMMigrateMem_disp, + &clGetDeviceAndHostTimer_disp, + &clGetHostTimer_disp, + &clGetKernelSubGroupInfo_disp, + &clSetDefaultDeviceCommandQueue_disp, + + /* OpenCL 2.2 */ + &clSetProgramReleaseCallback_disp, + &clSetProgramSpecializationConstant_disp, + + /* OpenCL 3.0 */ + &clCreateBufferWithProperties_disp, + &clCreateImageWithProperties_disp, + &clSetContextDestructorCallback_disp +}; +#endif // defined(CL_ENABLE_LAYERS) +#ifdef __cplusplus +} +#endif diff --git a/loader/icd_platform.h b/loader/icd_platform.h index b16d0db..0f3e432 100644 --- a/loader/icd_platform.h +++ b/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/loader/icd_version.h b/loader/icd_version.h new file mode 100644 index 0000000..1ecd343 --- /dev/null +++ b/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/loader/linux/icd_exports.map b/loader/linux/icd_exports.map index c716a39..f9299c3 100644 --- a/loader/linux/icd_exports.map +++ b/loader/linux/icd_exports.map @@ -163,3 +163,10 @@ OPENCL_2.2 { clSetProgramReleaseCallback; clSetProgramSpecializationConstant; } OPENCL_2.1; + +OPENCL_3.0 { + global: + clCreateBufferWithProperties; + clCreateImageWithProperties; + clSetContextDestructorCallback; +} OPENCL_2.2; diff --git a/loader/linux/icd_linux.c b/loader/linux/icd_linux.c index f6ae790..44915fe 100644 --- a/loader/linux/icd_linux.c +++ b/loader/linux/icd_linux.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2019 The Khronos Group Inc. + * 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. @@ -24,115 +24,183 @@ #include #include #include +#include #include #include +#include static pthread_once_t initialized = PTHREAD_ONCE_INIT; /* - * + * * Vendor enumeration functions * */ -// 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(((struct dirElem *)a)->d_name, ((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; - 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); + 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) ) - { - switch(dirEntry->d_type) - { - case DT_UNKNOWN: - case DT_REG: - case DT_LNK: - { - const char* extension = ".icd"; - FILE *fin = NULL; - char* fileName = NULL; - char* buffer = NULL; - long bufferSize = 0; - - // make sure the file name ends in .icd - if (strlen(extension) > strlen(dirEntry->d_name) ) - { - break; - } - if (strcmp(dirEntry->d_name + strlen(dirEntry->d_name) - strlen(extension), extension) ) - { - break; - } + struct dirent *dirEntry = NULL; - // allocate space for the full path of the vendor library name - fileName = malloc(strlen(dirEntry->d_name) + strlen(vendorPath) + 1); - if (!fileName) - { - KHR_ICD_TRACE("Failed allocate space for ICD file path\n"); - break; - } - sprintf(fileName, "%s%s", vendorPath, dirEntry->d_name); - - // open the file and read its contents - fin = fopen(fileName, "r"); - if (!fin) - { - free(fileName); - break; - } - fseek(fin, 0, SEEK_END); - bufferSize = ftell(fin); - - buffer = malloc(bufferSize+1); - if (!buffer) - { - free(fileName); - fclose(fin); - break; - } - memset(buffer, 0, bufferSize+1); - fseek(fin, 0, SEEK_SET); - if (bufferSize != (long)fread(buffer, 1, bufferSize, fin) ) - { - free(fileName); - free(buffer); - fclose(fin); - break; - } - // ignore a newline at the end of the file - if (buffer[bufferSize-1] == '\n') buffer[bufferSize-1] = '\0'; + // 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; - // load the string read from the file - khrIcdVendorAdd(buffer); + // 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; - free(fileName); - free(buffer); - fclose(fin); + 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++; } - break; - default: - break; + 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); + } + free(dirElems); } - } + } else + // use system provided ordering + for (dirEntry = readdir(dir); dirEntry; dirEntry = readdir(dir) ) + khrIcdOsDirEntryValidateAndAdd(dirEntry->d_name, path, extension, addFunc); closedir(dir); } @@ -143,6 +211,22 @@ void khrIcdOsVendorsEnumerate(void) } } +// 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) +} + // go through the list of vendors only once void khrIcdOsVendorsEnumerateOnce(void) { @@ -150,7 +234,7 @@ void khrIcdOsVendorsEnumerateOnce(void) } /* - * + * * Dynamic library loading functions * */ @@ -158,7 +242,12 @@ void khrIcdOsVendorsEnumerateOnce(void) // dynamically load a library. returns NULL on failure void *khrIcdOsLibraryLoad(const char *libraryName) { - return dlopen (libraryName, RTLD_NOW); + void* ret = dlopen (libraryName, RTLD_NOW); + if (NULL == ret) + { + KHR_ICD_TRACE("Failed to load driver because %s.\n", dlerror()); + } + return ret; } // get a function pointer from a loaded library. returns NULL on failure. @@ -172,4 +261,3 @@ void khrIcdOsLibraryUnload(void *library) { dlclose(library); } - diff --git a/loader/linux/icd_linux_envvars.c b/loader/linux/icd_linux_envvars.c index 4af5a08..ee6871a 100644 --- a/loader/linux/icd_linux_envvars.c +++ b/loader/linux/icd_linux_envvars.c @@ -21,9 +21,10 @@ #define _GNU_SOURCE #endif -#include "icd_cmake_config.h" +//#include "icd_cmake_config.h" #include +#include char *khrIcd_getenv(const char *name) { // No allocation of memory necessary for Linux. @@ -42,16 +43,16 @@ char *khrIcd_secure_getenv(const char *name) { return geteuid() != getuid() || getegid() != getgid() ? NULL : khrIcd_getenv(name); #else // Linux -#ifdef HAVE_SECURE_GETENV - return secure_getenv(name); -#elif defined(HAVE___SECURE_GETENV) - return __secure_getenv(name); -#else -#pragma message( \ - "Warning: Falling back to non-secure getenv for environmental lookups! Consider" \ - " updating to a different libc.") +//#ifdef HAVE_SECURE_GETENV + //return secure_getenv(name); +//##elif defined(HAVE___SECURE_GETENV) + //return __secure_getenv(name); +//#else +//#pragma message( \ +// "Warning: Falling back to non-secure getenv for environmental lookups! Consider" \ +// " updating to a different libc.") return khrIcd_getenv(name); -#endif +//#endif #endif } diff --git a/loader/windows/OpenCL-mingw-i686.def b/loader/windows/OpenCL-mingw-i686.def new file mode 100644 index 0000000..b7045a0 --- /dev/null +++ b/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/loader/windows/OpenCL.def b/loader/windows/OpenCL.def index 98abc9b..ed451bf 100644 --- a/loader/windows/OpenCL.def +++ b/loader/windows/OpenCL.def @@ -160,3 +160,7 @@ clSetDefaultDeviceCommandQueue clSetProgramReleaseCallback clSetProgramSpecializationConstant +; OpenCL 3.0 API +clCreateBufferWithProperties +clCreateImageWithProperties +clSetContextDestructorCallback diff --git a/loader/windows/OpenCL.rc b/loader/windows/OpenCL.rc index e70ef06..7c44cd4 100644 --- a/loader/windows/OpenCL.rc +++ b/loader/windows/OpenCL.rc @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2019 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 2 -#define OPENCL_ICD_LOADER_VERSION_MINOR 2 -#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-2019" + 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/loader/windows/adapter.h b/loader/windows/adapter.h new file mode 100644 index 0000000..ef97d66 --- /dev/null +++ b/loader/windows/adapter.h @@ -0,0 +1,80 @@ +/* +* Copyright (c) 2019 The Khronos Group Inc. +* Copyright (c) 2019 Valve Corporation +* Copyright (c) 2019 LunarG, 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. +* +* Author: Lenny Komow +*/ + +typedef struct LoaderEnumAdapters2 { + ULONG adapter_count; + struct { + UINT handle; + LUID luid; + ULONG source_count; + BOOL present_move_regions_preferred; + } * adapters; +} LoaderEnumAdapters2; + +typedef _Check_return_ NTSTATUS(APIENTRY *PFN_LoaderEnumAdapters2)(const LoaderEnumAdapters2 *); + +typedef enum AdapterInfoType { + LOADER_QUERY_TYPE_REGISTRY = 48, +} AdapterInfoType; + +typedef struct LoaderQueryAdapterInfo { + UINT handle; + AdapterInfoType type; + VOID *private_data; + UINT private_data_size; +} LoaderQueryAdapterInfo; + +typedef _Check_return_ NTSTATUS(APIENTRY *PFN_LoaderQueryAdapterInfo)(const LoaderQueryAdapterInfo *); + +typedef enum LoaderQueryRegistryType { + LOADER_QUERY_REGISTRY_ADAPTER_KEY = 1, +} LoaderQueryRegistryType; + +typedef enum LoaderQueryRegistryStatus { + LOADER_QUERY_REGISTRY_STATUS_SUCCESS = 0, + LOADER_QUERY_REGISTRY_STATUS_BUFFER_OVERFLOW = 1, +} LoaderQueryRegistryStatus; + +typedef struct LoaderQueryRegistryFlags { + union { + struct { + UINT translate_path : 1; + UINT mutable_value : 1; + UINT reserved : 30; + }; + UINT value; + }; +} LoaderQueryRegistryFlags; + +typedef struct LoaderQueryRegistryInfo { + LoaderQueryRegistryType query_type; + LoaderQueryRegistryFlags query_flags; + WCHAR value_name[MAX_PATH]; + ULONG value_type; + ULONG physical_adapter_index; + ULONG output_value_size; + LoaderQueryRegistryStatus status; + union { + DWORD output_dword; + UINT64 output_qword; + WCHAR output_string[1]; + BYTE output_binary[1]; + }; +} LoaderQueryRegistryInfo; diff --git a/loader/windows/icd_windows.c b/loader/windows/icd_windows.c index 9c87817..d771625 100644 --- a/loader/windows/icd_windows.c +++ b/loader/windows/icd_windows.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2016-2019 The Khronos Group Inc. + * 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. @@ -16,39 +16,203 @@ * OpenCL is a trademark of Apple Inc. used under license by Khronos. */ +#include + #include "icd.h" +#include "icd_windows.h" #include "icd_windows_hkr.h" #include "icd_windows_dxgk.h" +#include "icd_windows_apppackage.h" #include +#include #include #include +#include +typedef HRESULT (WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID, void **); + static INIT_ONCE initialized = INIT_ONCE_STATIC_INIT; +typedef struct WinAdapter +{ + char * szName; + LUID luid; +} WinAdapter; + +const LUID ZeroLuid = { 0, 0 }; + +static WinAdapter* pWinAdapterBegin = NULL; +static WinAdapter* pWinAdapterEnd = NULL; +static WinAdapter* pWinAdapterCapacity = NULL; + +BOOL adapterAdd(const char* szName, LUID luid) +{ + BOOL result = TRUE; + if (pWinAdapterEnd == pWinAdapterCapacity) + { + size_t oldCapacity = pWinAdapterCapacity - pWinAdapterBegin; + size_t newCapacity = oldCapacity; + if (0 == newCapacity) + { + newCapacity = 1; + } + else if(newCapacity < UINT_MAX/2) + { + newCapacity *= 2; + } + + WinAdapter* pNewBegin = malloc(newCapacity * sizeof(*pWinAdapterBegin)); + if (!pNewBegin) + result = FALSE; + else + { + if (pWinAdapterBegin) + { + memcpy(pNewBegin, pWinAdapterBegin, oldCapacity * sizeof(*pWinAdapterBegin)); + free(pWinAdapterBegin); + } + pWinAdapterCapacity = pNewBegin + newCapacity; + pWinAdapterEnd = pNewBegin + oldCapacity; + pWinAdapterBegin = pNewBegin; + } + } + if (pWinAdapterEnd != pWinAdapterCapacity) + { + size_t nameLen = (strlen(szName) + 1)*sizeof(szName[0]); + pWinAdapterEnd->szName = malloc(nameLen); + if (!pWinAdapterEnd->szName) + result = FALSE; + else + { + memcpy(pWinAdapterEnd->szName, szName, nameLen); + pWinAdapterEnd->luid = luid; + ++pWinAdapterEnd; + } + } + return result; +} + +void adapterFree(WinAdapter *pWinAdapter) +{ + free(pWinAdapter->szName); + 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 * */ -// go through the list of vendors in the registry and call khrIcdVendorAdd +// go through the list of vendors in the registry and call khrIcdVendorAdd // for each vendor encountered BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVOID *lpContext) { LONG result; + BOOL status = FALSE, currentStatus = FALSE; const char* platformsName = "SOFTWARE\\Khronos\\OpenCL\\Vendors"; HKEY platformsKey = NULL; DWORD dwIndex; + khrIcdInitializeTrace(); khrIcdVendorsEnumerateEnv(); - if (!khrIcdOsVendorsEnumerateDXGK()) + currentStatus = khrIcdOsVendorsEnumerateDXGK(); + status |= currentStatus; + if (!currentStatus) { KHR_ICD_TRACE("Failed to load via DXGK interface on RS4, continuing\n"); - if (!khrIcdOsVendorsEnumerateHKR()) - { - KHR_ICD_TRACE("Failed to enumerate HKR entries, continuing\n"); - } + } + + currentStatus = khrIcdOsVendorsEnumerateHKR(); + status |= currentStatus; + if (!currentStatus) + { + KHR_ICD_TRACE("Failed to enumerate HKR entries, continuing\n"); + } + + currentStatus = khrIcdOsVendorsEnumerateAppPackage(); + status |= currentStatus; + if (!currentStatus) + { + KHR_ICD_TRACE("Failed to enumerate App package entry, continuing\n"); } KHR_ICD_TRACE("Opening key HKLM\\%s...\n", platformsName); @@ -74,7 +238,7 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO DWORD dwValueSize = sizeof(dwValue); // read the value name - KHR_ICD_TRACE("Reading value %d...\n", dwIndex); + KHR_ICD_TRACE("Reading value %"PRIuDW"...\n", dwIndex); result = RegEnumValueA( platformsKey, dwIndex, @@ -87,11 +251,11 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO // if RegEnumKeyEx fails, we are done with the enumeration if (ERROR_SUCCESS != result) { - KHR_ICD_TRACE("Failed to read value %d, done reading key.\n", dwIndex); + 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 and equal zero if (REG_DWORD != dwLibraryNameType) { @@ -103,19 +267,138 @@ BOOL CALLBACK khrIcdOsVendorsEnumerate(PINIT_ONCE InitOnce, PVOID Parameter, PVO KHR_ICD_TRACE("Value not zero, skipping\n"); continue; } - // add the library - khrIcdVendorAdd(cszLibraryName); + status |= adapterAdd(cszLibraryName, ZeroLuid); } + } + + // Add adapters according to DXGI's preference order + HMODULE hDXGI = LoadLibraryA("dxgi.dll"); + if (hDXGI) + { + IDXGIFactory* pFactory = NULL; + PFN_CREATE_DXGI_FACTORY pCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY)GetProcAddress(hDXGI, "CreateDXGIFactory"); + if (pCreateDXGIFactory) + { + HRESULT hr = pCreateDXGIFactory(&IID_IDXGIFactory, (void **)&pFactory); + if (SUCCEEDED(hr)) + { + UINT i = 0; + IDXGIAdapter* pAdapter = NULL; + while (SUCCEEDED(pFactory->lpVtbl->EnumAdapters(pFactory, i++, &pAdapter))) + { + DXGI_ADAPTER_DESC AdapterDesc; + if (SUCCEEDED(pAdapter->lpVtbl->GetDesc(pAdapter, &AdapterDesc))) + { + for (WinAdapter* iterAdapter = pWinAdapterBegin; iterAdapter != pWinAdapterEnd; ++iterAdapter) + { + if (iterAdapter->luid.LowPart == AdapterDesc.AdapterLuid.LowPart + && iterAdapter->luid.HighPart == AdapterDesc.AdapterLuid.HighPart) + { + khrIcdVendorAdd(iterAdapter->szName); + break; + } + } + } + + pAdapter->lpVtbl->Release(pAdapter); + } + pFactory->lpVtbl->Release(pFactory); + } + } + FreeLibrary(hDXGI); + } + + // Go through the list again, putting any remaining adapters at the end of the list in an undefined order + for (WinAdapter* iterAdapter = pWinAdapterBegin; iterAdapter != pWinAdapterEnd; ++iterAdapter) + { + khrIcdVendorAdd(iterAdapter->szName); + adapterFree(iterAdapter); + } + + free(pWinAdapterBegin); + pWinAdapterBegin = NULL; + pWinAdapterEnd = NULL; + pWinAdapterCapacity = NULL; + + result = RegCloseKey(platformsKey); + if (ERROR_SUCCESS != result) + { + 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); - result = RegCloseKey(platformsKey); - if (ERROR_SUCCESS != result) + // 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) { - KHR_ICD_TRACE("Failed to close platforms key %s, ignoring\n", platformsName); + khrIcdLayerAdd(iterLayer->szName); + layerFree(iterLayer); } } - return TRUE; + free(pWinLayerBegin); + pWinLayerBegin = NULL; + pWinLayerEnd = NULL; + pWinLayerCapacity = NULL; + + result = RegCloseKey(layersKey); + + khrIcdLayersEnumerateEnv(); +#endif // defined(CL_ENABLE_LAYERS) + return status; } // go through the list of vendors only once @@ -123,9 +406,9 @@ void khrIcdOsVendorsEnumerateOnce() { InitOnceExecuteOnce(&initialized, khrIcdOsVendorsEnumerate, NULL, NULL); } - + /* - * + * * Dynamic library loading functions * */ @@ -133,7 +416,16 @@ void khrIcdOsVendorsEnumerateOnce() // dynamically load a library. returns NULL on failure void *khrIcdOsLibraryLoad(const char *libraryName) { - return (void *)LoadLibraryA(libraryName); + HMODULE hTemp = LoadLibraryExA(libraryName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); + if (!hTemp && GetLastError() == ERROR_INVALID_PARAMETER) + { + hTemp = LoadLibraryExA(libraryName, NULL, 0); + } + if (!hTemp) + { + KHR_ICD_TRACE("Failed to load driver. Windows error code is %"PRIuDW".\n", GetLastError()); + } + return (void*)hTemp; } // get a function pointer from a loaded library. returns NULL on failure. @@ -151,4 +443,3 @@ void khrIcdOsLibraryUnload(void *library) { FreeLibrary( (HMODULE)library); } - diff --git a/loader/windows/icd_windows.h b/loader/windows/icd_windows.h new file mode 100644 index 0000000..c25b13f --- /dev/null +++ b/loader/windows/icd_windows.h @@ -0,0 +1,46 @@ +/* + * 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 +#include + +#ifdef _LP64 +#define PRIDW_PREFIX +#define PRIUL_PREFIX +#else +#define PRIDW_PREFIX "l" +#define PRIUL_PREFIX "l" +#endif +#define PRIuDW PRIDW_PREFIX "u" +#define PRIxDW PRIDW_PREFIX "x" +#define PRIuUL PRIUL_PREFIX "u" +#define PRIxUL PRIUL_PREFIX "x" + +#ifdef __cplusplus +extern "C" { +#endif +extern const LUID ZeroLuid; + +BOOL adapterAdd(const char* szName, LUID luid); + +// Do not free the memory returned by this function. +const char* getOpenCLRegKeyName(void); + +#ifdef __cplusplus +} +#endif diff --git a/loader/windows/icd_windows_apppackage.c b/loader/windows/icd_windows_apppackage.c new file mode 100644 index 0000000..d957155 --- /dev/null +++ b/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/loader/windows/icd_windows_apppackage.h b/loader/windows/icd_windows_apppackage.h new file mode 100644 index 0000000..5419ad4 --- /dev/null +++ b/loader/windows/icd_windows_apppackage.h @@ -0,0 +1,22 @@ +/* + * 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 +#include "icd_windows.h" + +bool khrIcdOsVendorsEnumerateAppPackage(void); diff --git a/loader/windows/icd_windows_dxgk.c b/loader/windows/icd_windows_dxgk.c index 8cc3fb9..a610b9b 100644 --- a/loader/windows/icd_windows_dxgk.c +++ b/loader/windows/icd_windows_dxgk.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017-2019 The Khronos Group Inc. + * Copyright (c) 2017-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. @@ -19,136 +19,163 @@ #include "icd.h" #include "icd_windows_dxgk.h" -#if defined(OPENCL_ICD_LOADER_REQUIRE_WDK) #include +#include "adapter.h" #ifndef NTSTATUS typedef LONG NTSTATUS; #define STATUS_SUCCESS ((NTSTATUS)0x00000000L) #define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023) -#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0) -#endif - -#include +#define NT_SUCCESS(status) (((NTSTATUS)(status)) >= 0) #endif bool khrIcdOsVendorsEnumerateDXGK(void) { bool ret = false; -#if defined(OPENCL_ICD_LOADER_REQUIRE_WDK) -#if defined(DXGKDDI_INTERFACE_VERSION_WDDM2_4) && (DXGKDDI_INTERFACE_VERSION >= DXGKDDI_INTERFACE_VERSION_WDDM2_4) - { - D3DKMT_ADAPTERINFO* pAdapterInfo = NULL; - D3DKMT_ENUMADAPTERS2 EnumAdapters; - NTSTATUS Status = STATUS_SUCCESS; + int result = 0; - // Get handle to GDI Runtime - HMODULE h = LoadLibrary("gdi32.dll"); - KHR_ICD_ASSERT(h != NULL); + // Get handle to GDI Runtime + HMODULE h = LoadLibraryA("gdi32.dll"); + if (h == NULL) + return ret; - char cszLibraryName[MAX_PATH] = { 0 }; - PFND3DKMT_ENUMADAPTERS2 pEnumAdapters2 = (PFND3DKMT_ENUMADAPTERS2)GetProcAddress((HMODULE)h, "D3DKMTEnumAdapters2"); + if(GetProcAddress(h, "D3DKMTSubmitPresentBltToHwQueue")) // OS Version check + { + LoaderEnumAdapters2 EnumAdapters; + NTSTATUS status = STATUS_SUCCESS; + + EnumAdapters.adapter_count = 0; + EnumAdapters.adapters = NULL; + PFN_LoaderEnumAdapters2 pEnumAdapters2 = (PFN_LoaderEnumAdapters2)GetProcAddress(h, "D3DKMTEnumAdapters2"); if (!pEnumAdapters2) { - KHR_ICD_TRACE("GetProcAddress failed for D3DKMT_ENUMADAPTERS2\n"); + KHR_ICD_TRACE("GetProcAddress failed for D3DKMTEnumAdapters2\n"); + goto out; + } + PFN_LoaderQueryAdapterInfo pQueryAdapterInfo = (PFN_LoaderQueryAdapterInfo)GetProcAddress(h, "D3DKMTQueryAdapterInfo"); + if (!pQueryAdapterInfo) + { + KHR_ICD_TRACE("GetProcAddress failed for D3DKMTQueryAdapterInfo\n"); goto out; } while (1) { - EnumAdapters.NumAdapters = 0; - EnumAdapters.pAdapters = NULL; - Status = pEnumAdapters2(&EnumAdapters); - if (Status == STATUS_BUFFER_TOO_SMALL) + EnumAdapters.adapter_count = 0; + EnumAdapters.adapters = NULL; + status = pEnumAdapters2(&EnumAdapters); + if (status == STATUS_BUFFER_TOO_SMALL) { // Number of Adapters increased between calls, retry; continue; } - else if (!NT_SUCCESS(Status)) + else if (!NT_SUCCESS(status)) { - KHR_ICD_TRACE("D3DKMT_ENUMADAPTERS2 status != SUCCESS\n"); + KHR_ICD_TRACE("D3DKMTEnumAdapters2 status != SUCCESS\n"); goto out; } break; } - pAdapterInfo = (D3DKMT_ADAPTERINFO*)malloc(sizeof(D3DKMT_ADAPTERINFO)*(EnumAdapters.NumAdapters)); - if (pAdapterInfo == NULL) + EnumAdapters.adapters = malloc(sizeof(*EnumAdapters.adapters)*(EnumAdapters.adapter_count)); + if (EnumAdapters.adapters == NULL) { - KHR_ICD_TRACE("Allocation failure for AdapterInfo buffer\n"); + KHR_ICD_TRACE("Allocation failure for adapters buffer\n"); goto out; } - EnumAdapters.pAdapters = pAdapterInfo; - Status = pEnumAdapters2(&EnumAdapters); - if (!NT_SUCCESS(Status)) + status = pEnumAdapters2(&EnumAdapters); + if (!NT_SUCCESS(status)) { - KHR_ICD_TRACE("D3DKMT_ENUMADAPTERS2 status != SUCCESS\n"); + KHR_ICD_TRACE("D3DKMTEnumAdapters2 status != SUCCESS\n"); goto out; } - for (UINT AdapterIndex = 0; AdapterIndex < EnumAdapters.NumAdapters; AdapterIndex++) + const char* cszOpenCLRegKeyName = getOpenCLRegKeyName(); + const int szOpenCLRegKeyName = (int)(strlen(cszOpenCLRegKeyName) + 1)*sizeof(cszOpenCLRegKeyName[0]); + for (UINT AdapterIndex = 0; AdapterIndex < EnumAdapters.adapter_count; AdapterIndex++) { - D3DDDI_QUERYREGISTRY_INFO QueryArgs = {0}; - D3DDDI_QUERYREGISTRY_INFO* pQueryArgs = &QueryArgs; - D3DDDI_QUERYREGISTRY_INFO* pQueryBuffer = NULL; - QueryArgs.QueryType = D3DDDI_QUERYREGISTRY_ADAPTERKEY; - QueryArgs.QueryFlags.TranslatePath = TRUE; - QueryArgs.ValueType = REG_SZ; -#ifdef _WIN64 - wcscpy_s(QueryArgs.ValueName, ARRAYSIZE(L"OpenCLDriverName"), L"OpenCLDriverName"); -#else - // There is no WOW prefix for 32bit Windows hence make a specific check - BOOL is_wow64; - if (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64) - { - wcscpy_s(QueryArgs.ValueName, ARRAYSIZE(L"OpenCLDriverNameWow"), L"OpenCLDriverNameWow"); - } - else + LoaderQueryRegistryInfo queryArgs = {0}; + LoaderQueryRegistryInfo* pQueryArgs = &queryArgs; + LoaderQueryRegistryInfo* pQueryBuffer = NULL; + queryArgs.query_type = LOADER_QUERY_REGISTRY_ADAPTER_KEY; + queryArgs.query_flags.translate_path = TRUE; + queryArgs.value_type = REG_SZ; + result = MultiByteToWideChar( + CP_UTF8, + 0, + cszOpenCLRegKeyName, + szOpenCLRegKeyName, + queryArgs.value_name, + ARRAYSIZE(queryArgs.value_name)); + if (!result) { - wcscpy_s(QueryArgs.ValueName, ARRAYSIZE(L"OpenCLDriverName"), L"OpenCLDriverName"); + KHR_ICD_TRACE("MultiByteToWideChar status != SUCCESS\n"); + continue; } -#endif - D3DKMT_QUERYADAPTERINFO QueryAdapterInfo = {0}; - QueryAdapterInfo.hAdapter = pAdapterInfo[AdapterIndex].hAdapter; - QueryAdapterInfo.Type = KMTQAITYPE_QUERYREGISTRY; - QueryAdapterInfo.pPrivateDriverData = &QueryArgs; - QueryAdapterInfo.PrivateDriverDataSize = sizeof(QueryArgs); - Status = D3DKMTQueryAdapterInfo(&QueryAdapterInfo); - if (!NT_SUCCESS(Status)) + LoaderQueryAdapterInfo queryAdapterInfo = {0}; + queryAdapterInfo.handle = EnumAdapters.adapters[AdapterIndex].handle; + queryAdapterInfo.type = LOADER_QUERY_TYPE_REGISTRY; + queryAdapterInfo.private_data = &queryArgs; + queryAdapterInfo.private_data_size = sizeof(queryArgs); + status = pQueryAdapterInfo(&queryAdapterInfo); + if (!NT_SUCCESS(status)) { - KHR_ICD_TRACE("D3DKMT_QUERYADAPTERINFO status != SUCCESS\n"); - goto out; + // Try a different value type. Some vendors write the key as a multi-string type. + queryArgs.value_type = REG_MULTI_SZ; + status = pQueryAdapterInfo(&queryAdapterInfo); + if (NT_SUCCESS(status)) + { + KHR_ICD_TRACE("Accepting multi-string registry key type\n"); + } + else + { + // Continue trying to get as much info on each adapter as possible. + // It's too late to return FALSE and claim WDDM2_4 enumeration is not available here. + continue; + } } - if (NT_SUCCESS(Status) && pQueryArgs->Status == D3DDDI_QUERYREGISTRY_STATUS_BUFFER_OVERFLOW) + if (NT_SUCCESS(status) && pQueryArgs->status == LOADER_QUERY_REGISTRY_STATUS_BUFFER_OVERFLOW) { - ULONG QueryBufferSize = sizeof(D3DDDI_QUERYREGISTRY_INFO) + QueryArgs.OutputValueSize; - pQueryBuffer = (D3DDDI_QUERYREGISTRY_INFO*)malloc(QueryBufferSize); - memcpy(pQueryBuffer, &QueryArgs, sizeof(D3DDDI_QUERYREGISTRY_INFO)); - QueryAdapterInfo.pPrivateDriverData = pQueryBuffer; - QueryAdapterInfo.PrivateDriverDataSize = QueryBufferSize; - Status = D3DKMTQueryAdapterInfo(&QueryAdapterInfo); + ULONG queryBufferSize = sizeof(LoaderQueryRegistryInfo) + queryArgs.output_value_size; + pQueryBuffer = malloc(queryBufferSize); + if (pQueryBuffer == NULL) + continue; + memcpy(pQueryBuffer, &queryArgs, sizeof(LoaderQueryRegistryInfo)); + queryAdapterInfo.private_data = pQueryBuffer; + queryAdapterInfo.private_data_size = queryBufferSize; + status = pQueryAdapterInfo(&queryAdapterInfo); pQueryArgs = pQueryBuffer; } - if (NT_SUCCESS(Status) && pQueryArgs->Status == D3DDDI_QUERYREGISTRY_STATUS_SUCCESS) + if (NT_SUCCESS(status) && pQueryArgs->status == LOADER_QUERY_REGISTRY_STATUS_SUCCESS) { - wchar_t* pWchar = pQueryArgs->OutputString; - 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) { - size_t len = wcstombs(cszLibraryName, pWchar, sizeof(cszLibraryName)); - KHR_ICD_ASSERT(len == (sizeof(cszLibraryName) - 1)); - khrIcdVendorAdd(cszLibraryName); + KHR_ICD_TRACE("WideCharToMultiByte status != SUCCESS\n"); + } + else + { + ret |= adapterAdd(cszLibraryName, EnumAdapters.adapters[AdapterIndex].luid); } } - else if (Status == STATUS_INVALID_PARAMETER && pQueryArgs->Status == D3DDDI_QUERYREGISTRY_STATUS_FAIL) + else if (status == (NTSTATUS)STATUS_INVALID_PARAMETER) { free(pQueryBuffer); goto out; } free(pQueryBuffer); } - ret = true; out: - free(pAdapterInfo); - FreeLibrary(h); + free(EnumAdapters.adapters); } -#endif -#endif + + FreeLibrary(h); + return ret; } diff --git a/loader/windows/icd_windows_dxgk.h b/loader/windows/icd_windows_dxgk.h index f6cb65d..34bad64 100644 --- a/loader/windows/icd_windows_dxgk.h +++ b/loader/windows/icd_windows_dxgk.h @@ -17,5 +17,6 @@ */ #include +#include "icd_windows.h" bool khrIcdOsVendorsEnumerateDXGK(void); diff --git a/loader/windows/icd_windows_envvars.c b/loader/windows/icd_windows_envvars.c index c68cab6..3c17519 100644 --- a/loader/windows/icd_windows_envvars.c +++ b/loader/windows/icd_windows_envvars.c @@ -16,6 +16,8 @@ * OpenCL is a trademark of Apple Inc. used under license by Khronos. */ +#include +#include #include char *khrIcd_getenv(const char *name) { @@ -38,7 +40,36 @@ char *khrIcd_getenv(const char *name) { return retVal; } +static bool khrIcd_IsHighIntegrityLevel() +{ + bool isHighIntegrityLevel = false; + + HANDLE processToken; + if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY | TOKEN_QUERY_SOURCE, &processToken)) { + // Maximum possible size of SID_AND_ATTRIBUTES is maximum size of a SID + size of attributes DWORD. + char mandatoryLabelBuffer[SECURITY_MAX_SID_SIZE + sizeof(DWORD)] = {0}; + DWORD bufferSize; + if (GetTokenInformation(processToken, TokenIntegrityLevel, mandatoryLabelBuffer, sizeof(mandatoryLabelBuffer), + &bufferSize) != 0) { + const TOKEN_MANDATORY_LABEL* mandatoryLabel = (const TOKEN_MANDATORY_LABEL*)(mandatoryLabelBuffer); + const DWORD subAuthorityCount = *GetSidSubAuthorityCount(mandatoryLabel->Label.Sid); + const DWORD integrityLevel = *GetSidSubAuthority(mandatoryLabel->Label.Sid, subAuthorityCount - 1); + + isHighIntegrityLevel = integrityLevel > SECURITY_MANDATORY_MEDIUM_RID; + } + + CloseHandle(processToken); + } + + return isHighIntegrityLevel; +} + char *khrIcd_secure_getenv(const char *name) { + if (khrIcd_IsHighIntegrityLevel()) { + KHR_ICD_TRACE("Running at a high integrity level, so secure_getenv is returning NULL\n"); + return NULL; + } + return khrIcd_getenv(name); } diff --git a/loader/windows/icd_windows_hkr.c b/loader/windows/icd_windows_hkr.c index 3387181..ae4ba16 100644 --- a/loader/windows/icd_windows_hkr.c +++ b/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. @@ -19,6 +19,7 @@ #include "icd.h" #include "icd_windows_hkr.h" #include +#include "icd_windows_dxgk.h" #include #include #include @@ -51,7 +52,7 @@ static const char OPENCL_REG_SUB_KEY_WOW[] = "OpenCLDriverNameWow"; #endif // Do not free the memory returned by this function. -static const char* GetOpenCLRegKeyName(void) +const char* getOpenCLRegKeyName(void) { #ifdef _WIN64 return OPENCL_REG_SUB_KEY; @@ -89,14 +90,14 @@ static bool ReadOpenCLKey(DEVINST dnDevNode) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE("Failed with ret 0x%x\n", ret); + KHR_ICD_TRACE("Failed with ret 0x%"PRIxDW"\n", ret); goto out; } else { result = RegQueryValueExA( hkey, - GetOpenCLRegKeyName(), + getOpenCLRegKeyName(), NULL, &dwLibraryNameType, NULL, @@ -104,41 +105,46 @@ static bool ReadOpenCLKey(DEVINST dnDevNode) if (ERROR_SUCCESS != result) { - KHR_ICD_TRACE("Failed to open sub key 0x%x\n", result); + KHR_ICD_TRACE("Failed to open sub key 0x%"PRIxDW"\n", result); goto out; } cszOclPath = malloc(dwOclPathSize); if (NULL == cszOclPath) { - KHR_ICD_TRACE("Failed to allocate %u bytes for registry value\n", dwOclPathSize); + KHR_ICD_TRACE("Failed to allocate %"PRIuDW" bytes for registry value\n", dwOclPathSize); goto out; } result = RegQueryValueExA( hkey, - GetOpenCLRegKeyName(), + getOpenCLRegKeyName(), NULL, &dwLibraryNameType, (LPBYTE)cszOclPath, &dwOclPathSize); if (ERROR_SUCCESS != result) { - KHR_ICD_TRACE("Failed to open sub key 0x%x\n", result); + KHR_ICD_TRACE("Failed to open sub key 0x%"PRIxDW"\n", result); goto out; } if (REG_SZ != dwLibraryNameType) { - KHR_ICD_TRACE("Unexpected registry entry 0x%x! continuing\n", dwLibraryNameType); - goto out; + if (REG_MULTI_SZ == dwLibraryNameType) + { + KHR_ICD_TRACE("Accepting multi-string registry key type\n"); + } + else + { + KHR_ICD_TRACE("Unexpected registry entry 0x%"PRIxDW"! continuing\n", dwLibraryNameType); + goto out; + } } KHR_ICD_TRACE(" Path: %s\n", cszOclPath); - khrIcdVendorAdd(cszOclPath); - - bRet = true; + bRet |= adapterAdd(cszOclPath, ZeroLuid); } out: @@ -149,7 +155,7 @@ static bool ReadOpenCLKey(DEVINST dnDevNode) result = RegCloseKey(hkey); if (ERROR_SUCCESS != result) { - KHR_ICD_TRACE("WARNING: failed to close hkey 0x%x\n", result); + KHR_ICD_TRACE("WARNING: failed to close hkey 0x%"PRIxDW"\n", result); } } @@ -170,7 +176,7 @@ static DeviceProbeResult ProbeDevice(DEVINST devnode) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE(" WARNING: failed to probe the status of the device 0x%x\n", ret); + KHR_ICD_TRACE(" WARNING: failed to probe the status of the device 0x%"PRIxDW"\n", ret); return ProbeFailure; } @@ -188,7 +194,7 @@ static DeviceProbeResult ProbeDevice(DEVINST devnode) if (((ulStatus & DN_HAS_PROBLEM) && ulProblem == CM_PROB_NEED_RESTART) || ulStatus & DN_NEED_RESTART) { - KHR_ICD_TRACE(" WARNING: device is pending reboot (0x%x), skipping...\n", ulStatus); + KHR_ICD_TRACE(" WARNING: device is pending reboot (0x%" PRIxUL "), skipping...\n", ulStatus); return PendingReboot; } @@ -208,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, @@ -233,7 +243,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE("CM_Get_Device_ID_List_size failed with 0x%x\n", ret); + KHR_ICD_TRACE("CM_Get_Device_ID_List_size failed with 0x%"PRIxDW"\n", ret); break; } @@ -245,7 +255,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) deviceIdList = malloc(szBuffer * sizeof(wchar_t)); if (NULL == deviceIdList) { - KHR_ICD_TRACE("Failed to allocate %u bytes for device ID strings\n", szBuffer); + KHR_ICD_TRACE("Failed to allocate %" PRIuUL " bytes for device ID strings\n", szBuffer); break; } @@ -257,7 +267,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE("CM_Get_Device_ID_List failed with 0x%x\n", ret); + KHR_ICD_TRACE("CM_Get_Device_ID_List failed with 0x%"PRIxDW"\n", ret); KHR_SAFE_RELEASE(deviceIdList); } } while (CR_BUFFER_SMALL == ret); @@ -269,18 +279,16 @@ 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); if (CR_SUCCESS == ret) { - KHR_ICD_TRACE(" devinst: %d\n", devinst); + KHR_ICD_TRACE(" devinst: %lu\n", devinst); } else { - KHR_ICD_TRACE("CM_Locate_DevNode failed with 0x%x\n", ret); + KHR_ICD_TRACE("CM_Locate_DevNode failed with 0x%"PRIxDW"\n", ret); continue; } @@ -305,7 +313,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE(" CM_Get_Child returned 0x%x, skipping children...\n", ret); + KHR_ICD_TRACE(" CM_Get_Child returned 0x%"PRIxDW", skipping children...\n", ret); } else { @@ -315,7 +323,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) GUID guid; ULONG szGuid = sizeof(guid); - KHR_ICD_TRACE(" devchild: %d\n", devchild); + KHR_ICD_TRACE(" devchild: %lu\n", devchild); ret = CM_Get_Device_IDW( devchild, deviceInstanceID, @@ -324,7 +332,7 @@ bool khrIcdOsVendorsEnumerateHKR(void) if (CR_SUCCESS != ret) { - KHR_ICD_TRACE(" CM_Get_Device_ID returned 0x%x, skipping device...\n", ret); + KHR_ICD_TRACE(" CM_Get_Device_ID returned 0x%"PRIxDW", skipping device...\n", ret); continue; } else @@ -332,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/loader/windows/icd_windows_hkr.h b/loader/windows/icd_windows_hkr.h index 698fe5a..e0db713 100644 --- a/loader/windows/icd_windows_hkr.h +++ b/loader/windows/icd_windows_hkr.h @@ -17,5 +17,6 @@ */ #include +#include "icd_windows.h" bool khrIcdOsVendorsEnumerateHKR(void); diff --git a/scripts/.gitignore b/scripts/.gitignore new file mode 100644 index 0000000..01f6e38 --- /dev/null +++ b/scripts/.gitignore @@ -0,0 +1,2 @@ +gen/__pycache__ +*.c diff --git a/scripts/README.md b/scripts/README.md new file mode 100644 index 0000000..3da3547 --- /dev/null +++ b/scripts/README.md @@ -0,0 +1,35 @@ +# OpenCL ICD Loader Code Generation + +## Introduction + +In order to ease maintenance and enable faster development of related OpenCL ICD loader features, the OpenCL ICD loader API dispatch functions are generated from the OpenCL XML machine readable grammar. + +## Dependencies + +The API dispatch functions 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, 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 Files + +Files for the OpenCL ICD loader, or the test layer, may be generated by executing the scripts `gen_loader.py`, or `gen_print_layer.py`, respectively. + +The script requires the `cl.xml` machine readable grammar. +By default, the script searches for `cl.xml` in the current directory. +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 output from the script is placed in the current directory by default, to allow easy comparisons between the generated files and the current files. +After the generated files are evaluated, they should be manually copied into the source tree. +These steps may be automated in the future. diff --git a/scripts/androidbpgenerator.py b/scripts/androidbpgenerator.py new file mode 100755 index 0000000..98587be --- /dev/null +++ b/scripts/androidbpgenerator.py @@ -0,0 +1,313 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER 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. +""" + +import os +import os.path as path +import re + + +INDENT = " " +BUILD_DIR = "__build__" +TEMPLATE_DIR = "bp" +NOVERBOSE = " > /dev/null 2>&1;" + + +def remove(f): + cmd = "rm -f " + f + NOVERBOSE + os.system(cmd) + + +class CCDefaults: + # constructor + def __init__(self, proj, defname, cflags = [], cppflags = [], clang_cflags = [], + include_dirs = [], shared_libs = [], static_libs = [], bpfiles = []): + self.templ = path.join(proj, TEMPLATE_DIR) + self.proj = proj + self.default_name = defname + self.c_flag = cflags + self.cpp_flag = cppflags + self.clang_cflag = clang_cflags + self.include_dir = include_dirs + self.shared_lib = shared_libs + self.static_lib = static_libs + self.bp_file = bpfiles + + def getBpFilePath(self): + return path.join(self.proj, "Android.bp") + + #major function + def generate(self): + if path.exists(self.proj) == False: + raise Exception(self.proj + " not existed") + # read template + with open(path.join(self.templ, "defaults.tpl")) as f: + tpl = f.read() + # remove all comment + tpl = re.sub("#.*\n", "", tpl).strip() + # replacement + tpl = tpl.replace("@name", self.default_name) + tpl = tpl.replace("@cflags", self.convertList2Str(self.c_flag)) + tpl = tpl.replace("@cppflags", self.convertList2Str(self.cpp_flag)) + tpl = tpl.replace("@clang_cflags", self.convertList2Str(self.clang_cflag)) + tpl = tpl.replace("@include_dirs", self.convertList2Str(self.include_dir)) + tpl = tpl.replace("@shared_libs", self.convertList2Str(self.shared_lib)) + tpl = tpl.replace("@static_libs", self.convertList2Str(self.static_lib)) + tpl = tpl.replace("@build", self.convertList2Str(self.bp_file, indent_num = 1)) + + return tpl + + def convertList2Str(self, itemlist, indent_num = 2): + str = "" + + for i, t in enumerate(itemlist): + if 0 == len(t): + continue + str += INDENT * indent_num + "\"" + t + "\",\n" + + return INDENT * indent_num + "".join(str).strip() + + +class ModuleInfo: + # constructor + def __init__(self, modulename, bpfilename, cmakedir, moduletype, defaults, + middledir = "", addsrc = [], addflags = [], addstatic = [], addshared = [], + updateflags = {}, updatestatic = {}, updateshared = {}): + self.Module_Name = modulename # name of module + self.Bp_File_Name = bpfilename # BP file name + self.Mid_Dir = middledir # some middle directory + self.Build_Make = middledir + cmakedir + "build.make" # building file in directory generated by cmake + self.Flags_Make = middledir + cmakedir + "flags.make" # flag-file in directory generated by cmake + self.Module_Type = moduletype # support: cc_library_shared, cc_library_static + self.Defaults = INDENT * 2 + "\"" + defaults + "\"," + self.Add_Src = addsrc # some additional source files + self.Add_Flags = addflags # some additional cflags/cppflags + self.Add_Static = addstatic # some additional static library + self.Add_Shared = addshared # some additional shared library + self.Update_Flags = updateflags # update some cflags/cppflags + self.Update_Static = updatestatic # update the dependent static libraries + self.Update_Shared = updateshared # update the dependent static libraries + + +class Generator: + # constructor + def __init__(self, src, root): + # where is the major source file, and the directory to where *.bp should be put + self.src = src + # where to put build file and template + self.build = path.join(root, BUILD_DIR) + """where to put the template""" + self.templ = path.join(src, TEMPLATE_DIR) + # all submodule's info + self.allmoduleinfo = {} + # + # self.allmoduledefaults = CCDefaults(...) + + #major function + def generate(self, to_cmake = True, to_make = False): + if path.exists(self.src) == False: + raise Exception(self.src + " not existed") + + if to_cmake: + self.generateMakefile(make = to_make) + + self.adjustFiles() + + allBPs = {} + # sub-module" .bp + for k in list(self.allmoduleinfo.keys()): + # the path of Android.bp + bp = path.normpath(path.join(self.src, self.allmoduleinfo[k].Bp_File_Name)) + # read template + with open(self.getTemplatePath()) as f: + tpl = f.read() + # remove all comment + tpl = re.sub("#.*\n", "", tpl).strip() + # an Android.bp is related to some module + if bp in list(allBPs.keys()): + allBPs[bp] += "\n\n" + self.replaceTemplate(k, tpl) + else: + allBPs[bp] = self.replaceTemplate(k, tpl) + # Android.bp + allBPs[self.allmoduledefaults.getBpFilePath()] = self.allmoduledefaults.generate() + + for bp in list(allBPs.keys()): + # remove old Android.bp + remove(bp) + # create new Android.bp + with open(bp, "w") as f: + f.write(allBPs[bp]) + print((bp + " has been generated.")) + + #virtuall functions + def getTemplate(self): + raise Exception("pure virtul function") + + def replaceTemplate(self, mode, tpl): + tpl = tpl.replace("@module", self.allmoduleinfo[mode].Module_Type) + tpl = tpl.replace("@name", self.allmoduleinfo[mode].Module_Name) + tpl = tpl.replace("@defaults", self.allmoduleinfo[mode].Defaults) + tpl = tpl.replace("@srcs", self.getSources(mode)) + tpl = tpl.replace("@cflags", self.adjustFlags(mode, INDENT * 2 + "".join(self.getDefines(mode, "C_FLAGS") + self.getDefines(mode, "C_DEFINES")).strip(), is_add = False)) + tpl = tpl.replace("@cppflags", self.adjustFlags(mode, INDENT * 2 + "".join(self.getDefines(mode, "CXX_FLAGS") + self.getDefines(mode, "CXX_DEFINES")).strip())) + tpl = tpl.replace("@local_include_dirs", INDENT * 2 + "".join(self.getIncludes(mode, "C_INCLUDES") + "\n" + self.getIncludes(mode, "CXX_INCLUDES")).strip()) + tpl = tpl.replace("@shared_libs", INDENT * 2 + "".join(self.adjustLibrary(mode, self.getLibrary(mode, ".*?\\.so[.\d]*\\n", "\\.so)[.\d]*\\n", "\\.so[.\d]*"), False).strip())) + tpl = tpl.replace("@static_libs", INDENT * 2 + "".join(self.adjustLibrary(mode, self.getLibrary(mode, ".*?\\.a\\n", "\\.a)\\n", "\\.a")).strip())) + + return tpl + + def getName(self): + return self.getTemplate().split(".")[0] + + def getTemplatePath(self): + return path.join(self.templ, self.getTemplate()) + + def getBuildDir(self): + return path.join(self.build, self.getName()) + + def adjustSources(self, mode, all_sources): + return all_sources + + def adjustIncludes(self, mode, all_includes): + return all_includes + + def adjustFlags(self, mode, all_flags, is_add = True): + return all_flags + + def adjustLibrary(self, mode, all_libs, is_static = True): + return all_libs + + def adjustFiles(self): + return + + def getCmakeCmd(self): + return "cmake -DCMAKE_BUILD_TYPE=Release " + self.src + + def generateMakefile(self, debug=False, make=False): + #windows can help us debug the script and we do not want generate makefile on widnows + if os.name == "nt": + return + + verbose = ";" if debug else NOVERBOSE + builddir = self.getBuildDir() + # make quickly, but can't clear old makefile + cmd = "rm " + path.join(builddir, "CMakeCache.txt") + verbose + # clear old makefile, but need to cost some time + #cmd = "rm -rf " + builddir + verbose + cmd += "mkdir -p " + builddir + verbose + cmd += "cd " + builddir + " && " + self.getCmakeCmd() + verbose + # need to make this project + if make: + print(("It is making: " + self.src)) + cmd += "make -j$(nproc)" + + os.system(cmd) + + def getIncludes(self, mode, title): + includestext = self.getDefines(mode, title) + if (0 == len(includestext)): + return "" + + lines = includestext.split("\n") + includesfile = [] + + for l in lines: + if 0 == len(l): + continue + #normpath will make sure we did not refer outside. + p = path.normpath(l) + j = p.find(self.src) + # + if 0 <= j: + # check this path of include is existed, or not. + k = p[j:].find('"') + if (0 <= k) and (True == path.isdir(p[j : (j + k)])): + includesfile.append(p[j:].replace(self.src, INDENT * 2 + "\"")) + + return "\n".join(includesfile) if includesfile else "" + + def getDefines(self, mode, title): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + flagsfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Flags_Make) + with open(flagsfile) as f: + text = f.read() + + lines = re.findall(title + " =.*\n", text) + if (0 == len(lines)): + return "" + + all_defines = "" + + for i, l in enumerate(lines): + # 'strip' to remove the beginning and ending space + l = l.replace(title + " = ", "").strip() + if (0 == len(l)): + continue + + all_defines += INDENT * 2 + "\"" + re.sub(r"[ ]+", "\",\n" + INDENT * 2 + "\"", re.sub("=\"\"", "=", l)) + "\",\n" + + return all_defines + + def getSources(self, mode): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + buildfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Build_Make) + with open(buildfile) as f: + text = f.read() + + lines = re.findall(".*?: .*?CMakeFiles/.*?\\.dir/.*?\\.o\\n", text) + lines = [l.replace(".o", "\",") for l in lines] + + self.adjustSources(mode, lines) + + #make source pretty + return INDENT * 2 + "".join(lines).strip() + + def getLibrary(self, mode, reg1, reg2, reg3): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + buildfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Build_Make) + with open(buildfile) as f: + text = f.read() + + lines = re.findall(reg1, text) + if (0 == len(lines)): + return "" + + all_lib = "" + for i, l in enumerate(lines): + if 0 == len(l) or re.search("(?<=" + self.allmoduleinfo[mode].Module_Name + reg2, l): + continue + + j = l.rfind(": ") + if 0 > j: + continue + + l = l[(j + 2):] + j = l.rfind('/') + all_lib += INDENT * 2 + "\"" + re.sub(reg3, "\",", l[(j + 1):] if 0 <= j else l) + + return all_lib \ No newline at end of file diff --git a/scripts/cleanicdloadergenerator.py b/scripts/cleanicdloadergenerator.py new file mode 100755 index 0000000..63cd24d --- /dev/null +++ b/scripts/cleanicdloadergenerator.py @@ -0,0 +1,49 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER 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. +""" + +import os +import os.path as path +from androidbpgenerator import BUILD_DIR, NOVERBOSE + + +class Main: + + def run(self): + script = path.dirname(__file__) + root = path.abspath(path.join(script, "../..")) + + print(("script = " + script)) + print(("root = " + root)) + + # remove all intermediate files and building directories + print("It is removing building directories and intermediate files for OpenCL-ICD-Loader ... ") + cmd = "rm -rf " + path.join(script, "__pycache__") + NOVERBOSE + cmd += "rm -rf " + path.join(root, BUILD_DIR) + NOVERBOSE + #cmd += "find " + path.join(script, "..") + " -name '*\.bp' -type f -delete" + NOVERBOSE + os.system(cmd) + + print("Done ! ") + + +m = Main() +m.run() \ No newline at end of file diff --git a/scripts/gen/__init__.py b/scripts/gen/__init__.py new file mode 100644 index 0000000..0f54cb4 --- /dev/null +++ b/scripts/gen/__init__.py @@ -0,0 +1,130 @@ +# Copyright (c) 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. + +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-Docs/main/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_apisigs(spec): + # Generate the API function signatures dictionary: + 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_apis(spec, apisigs): + # Generate the core API dictionary: + 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 + + # Generate the extensions API dictionary: + 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 (coreapis, extapis) + + diff --git a/scripts/gen_loader.py b/scripts/gen_loader.py new file mode 100644 index 0000000..38f84f1 --- /dev/null +++ b/scripts/gen_loader.py @@ -0,0 +1,43 @@ +#!/usr/bin/python3 + +# Copyright (c) 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. + +import gen +from mako.template import Template +from mako.exceptions import RichTraceback + +if __name__ == "__main__": + args = gen.parse_args() + spec = gen.load_spec(args) + apisigs = gen.get_apisigs(spec) + (coreapis, extapis) = gen.get_apis(spec, apisigs) + + try: + # Create the loader cpp file from the API dictionary: + test = open(args.directory + '/icd_dispatch_generated.c', 'wb') + icd_dispatch_generated_template = Template(filename='icd_dispatch_generated.c.mako') + test.write( + icd_dispatch_generated_template.render_unicode( + spec=spec, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis). + encode('utf-8', 'replace')) + 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/scripts/gen_print_layer.py b/scripts/gen_print_layer.py new file mode 100644 index 0000000..1a28883 --- /dev/null +++ b/scripts/gen_print_layer.py @@ -0,0 +1,43 @@ +#!/usr/bin/python3 + +# Copyright (c) 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. + +import gen +from mako.template import Template +from mako.exceptions import RichTraceback + +if __name__ == "__main__": + args = gen.parse_args() + spec = gen.load_spec(args) + apisigs = gen.get_apisigs(spec) + (coreapis, extapis) = gen.get_apis(spec, apisigs) + + try: + # Create the layer cpp file from the API dictionary: + test = open(args.directory + '/icd_print_layer_generated.c', 'wb') + icd_layer_generated_template = Template(filename='icd_print_layer_generated.c.mako') + test.write( + icd_layer_generated_template.render_unicode( + spec=spec, + apisigs=apisigs, + coreapis=coreapis, + extapis=extapis). + encode('utf-8', 'replace')) + 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/scripts/icd_dispatch_generated.c.mako b/scripts/icd_dispatch_generated.c.mako new file mode 100644 index 0000000..05a26fc --- /dev/null +++ b/scripts/icd_dispatch_generated.c.mako @@ -0,0 +1,489 @@ +<% +# APIs to skip - they need to be done "manually": +apiskip = { + 'clGetPlatformIDs', # to query platforms + 'clGetExtensionFunctionAddress', # to return ICD-aware extensions + 'clGetExtensionFunctionAddressForPlatform', # to return ICD-aware extensions + } + +apiinit = { + 'clCreateContextFromType', + 'clGetGLContextInfoKHR', + } +# Handles, and mappings to errors when handles are invalid: +apihandles = { + 'cl_command_queue' : 'CL_INVALID_COMMAND_QUEUE', + 'cl_context' : 'CL_INVALID_CONTEXT', + 'cl_device_id' : 'CL_INVALID_DEVICE', + 'cl_event' : 'CL_INVALID_EVENT', + 'cl_kernel' : 'CL_INVALID_KERNEL', + 'cl_mem' : 'CL_INVALID_MEM_OBJECT', + 'cl_platform_id' : 'CL_INVALID_PLATFORM', + 'cl_program' : 'CL_INVALID_PROGRAM', + 'cl_sampler' : 'CL_INVALID_SAMPLER', + } +%>/* + * 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. + * 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_dispatch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Core APIs: +%for apis in coreapis.values(): +%for api in apis: +%if not api.Name in apiskip: +<% + handle = api.Params[0] + if handle.Type in apihandles: + invalid = apihandles[handle.Type] + else: + invalid = 'NULL' +%> +%for disp in [0, 1]: +% if disp == 1: +#if defined(CL_ENABLE_LAYERS) +% endif +${("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}, +% else: + ${param.Type} ${param.Name}${param.TypeEnd}) +% endif +%endfor +{ +%if api.Name in apiinit: + khrIcdInitialize(); +%endif +%if disp == 0: +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) +% if api.Name == "clSVMFree": + { + khrFirstLayer->dispatch.${api.Name}( +% else: + return khrFirstLayer->dispatch.${api.Name}( +% endif +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% else: + ${param.Name}); +% endif +%endfor +% if api.Name == "clSVMFree": + } + else +% endif +#endif // defined(CL_ENABLE_LAYERS) +%endif +%if api.RetType in apihandles or api.RetType == "void*": +## clCreateContext is a special case, since it calls through +## the dispatch table via the first "device": +% if api.Name == "clCreateContext": + if (${api.Params[1].Name} == 0 || ${api.Params[2].Name} == NULL) { + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(NULL, CL_INVALID_VALUE); + } + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${api.Params[2].Name}[0], CL_INVALID_DEVICE); +## clCreateContextFromType is a special case, since it calls +## through a platform passed via properties: +% elif api.Name == "clCreateContextFromType": + cl_platform_id platform = NULL; + khrIcdContextPropertiesGetPlatform(properties, &platform); + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(platform, CL_INVALID_PLATFORM); +## These APIs are special cases because they return a void*, but +## do not nave an errcode_ret: +% elif api.Name == "clSVMAlloc" or api.Name == "clGetExtensionFunctionAddressForPlatform": + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, NULL); +% else: + KHR_ICD_VALIDATE_HANDLE_RETURN_HANDLE(${handle.Name}, ${invalid}); +% endif +%elif api.Name == "clSVMFree": +## clSVMFree has no return value or errcode_ret: + if (${handle.Name} != NULL) +## clWaitForEvents is a special case, since it calls through +## the dispatch table via the first "event": +%elif api.Name == "clWaitForEvents": + if (${api.Params[0].Name} == 0 || ${api.Params[1].Name} == NULL) { + return CL_INVALID_VALUE; + } + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${api.Params[1].Name}[0], CL_INVALID_EVENT); +%elif api.Name == "clUnloadCompiler": + // Nothing! +%else: + KHR_ICD_VALIDATE_HANDLE_RETURN_ERROR(${handle.Name}, ${invalid}); +%endif +%if api.Name == "clCreateContext": + return ${api.Params[2].Name}[0]->dispatch->${api.Name}( +%elif api.Name == "clWaitForEvents": + return ${api.Params[1].Name}[0]->dispatch->${api.Name}( +%elif api.Name == "clCreateContextFromType": + return platform->dispatch->${api.Name}( +%elif api.Name == "clSVMFree": + ${handle.Name}->dispatch->${api.Name}( +%elif api.Name == "clUnloadCompiler": + return CL_SUCCESS; +%else: + return ${handle.Name}->dispatch->${api.Name}( +%endif: +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% elif param.Name: # for clUnloadCompiler + ${param.Name}); +% endif +%endfor +} +% if disp == 1: +#endif // defined(CL_ENABLE_LAYERS) +% endif + +/////////////////////////////////////////////////////////////////////////////// +%endfor +%else: +#if defined(CL_ENABLE_LAYERS) +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}, +% else: + ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix}; +% endif +%endfor +#endif // defined(CL_ENABLE_LAYERS) +%endif +%endfor +%endfor +<% +icdextensions = [ + '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' + ] +win32extensions = { + 'cl_khr_d3d10_sharing', + 'cl_khr_d3d11_sharing', + 'cl_khr_dx9_media_sharing', + } +%> +%for extension in icdextensions: +<% + apis = extapis[extension] +%>// ${extension} +%if extension in win32extensions: + +#if defined(_WIN32) +%endif +%for api in apis: +<% + handle = api.Params[0] + if handle.Type in apihandles: + invalid = apihandles[handle.Type] + else: + invalid = 'NULL' +%> +%for disp in [0, 1]: +% if disp == 1: +#if defined(CL_ENABLE_LAYERS) +% endif +${("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}, +% else: + ${param.Type} ${param.Name}${param.TypeEnd}) +% endif +%endfor +{ +%if disp == 0: +#if defined(CL_ENABLE_LAYERS) + if (khrFirstLayer) + return khrFirstLayer->dispatch.${api.Name}( +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% else: + ${param.Name}); +% endif +%endfor +#endif // defined(CL_ENABLE_LAYERS) +%endif +%if api.RetType in apihandles or api.RetType == "void*": +% if False: + // 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": + return platform->dispatch->${api.Name}( +%else: + return ${handle.Name}->dispatch->${api.Name}( +%endif +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% elif param.Name: # for clUnloadCompiler + ${param.Name}); +% endif +%endfor +} +% if disp == 1: +#endif // defined(CL_ENABLE_LAYERS) +% endif +%endfor +%endfor + +%if extension in win32extensions: +#endif // defined(_WIN32) + +%endif +/////////////////////////////////////////////////////////////////////////////// + +%endfor +#if defined(CL_ENABLE_LAYERS) +struct _cl_icd_dispatch khrMasterDispatch = { + &clGetPlatformIDs_disp, + &clGetPlatformInfo_disp, + &clGetDeviceIDs_disp, + &clGetDeviceInfo_disp, + &clCreateContext_disp, + &clCreateContextFromType_disp, + &clRetainContext_disp, + &clReleaseContext_disp, + &clGetContextInfo_disp, + &clCreateCommandQueue_disp, + &clRetainCommandQueue_disp, + &clReleaseCommandQueue_disp, + &clGetCommandQueueInfo_disp, + &clSetCommandQueueProperty_disp, + &clCreateBuffer_disp, + &clCreateImage2D_disp, + &clCreateImage3D_disp, + &clRetainMemObject_disp, + &clReleaseMemObject_disp, + &clGetSupportedImageFormats_disp, + &clGetMemObjectInfo_disp, + &clGetImageInfo_disp, + &clCreateSampler_disp, + &clRetainSampler_disp, + &clReleaseSampler_disp, + &clGetSamplerInfo_disp, + &clCreateProgramWithSource_disp, + &clCreateProgramWithBinary_disp, + &clRetainProgram_disp, + &clReleaseProgram_disp, + &clBuildProgram_disp, + &clUnloadCompiler_disp, + &clGetProgramInfo_disp, + &clGetProgramBuildInfo_disp, + &clCreateKernel_disp, + &clCreateKernelsInProgram_disp, + &clRetainKernel_disp, + &clReleaseKernel_disp, + &clSetKernelArg_disp, + &clGetKernelInfo_disp, + &clGetKernelWorkGroupInfo_disp, + &clWaitForEvents_disp, + &clGetEventInfo_disp, + &clRetainEvent_disp, + &clReleaseEvent_disp, + &clGetEventProfilingInfo_disp, + &clFlush_disp, + &clFinish_disp, + &clEnqueueReadBuffer_disp, + &clEnqueueWriteBuffer_disp, + &clEnqueueCopyBuffer_disp, + &clEnqueueReadImage_disp, + &clEnqueueWriteImage_disp, + &clEnqueueCopyImage_disp, + &clEnqueueCopyImageToBuffer_disp, + &clEnqueueCopyBufferToImage_disp, + &clEnqueueMapBuffer_disp, + &clEnqueueMapImage_disp, + &clEnqueueUnmapMemObject_disp, + &clEnqueueNDRangeKernel_disp, + &clEnqueueTask_disp, + &clEnqueueNativeKernel_disp, + &clEnqueueMarker_disp, + &clEnqueueWaitForEvents_disp, + &clEnqueueBarrier_disp, + &clGetExtensionFunctionAddress_disp, + &clCreateFromGLBuffer_disp, + &clCreateFromGLTexture2D_disp, + &clCreateFromGLTexture3D_disp, + &clCreateFromGLRenderbuffer_disp, + &clGetGLObjectInfo_disp, + &clGetGLTextureInfo_disp, + &clEnqueueAcquireGLObjects_disp, + &clEnqueueReleaseGLObjects_disp, + &clGetGLContextInfoKHR_disp, + + /* cl_khr_d3d10_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromD3D10KHR_disp, + &clCreateFromD3D10BufferKHR_disp, + &clCreateFromD3D10Texture2DKHR_disp, + &clCreateFromD3D10Texture3DKHR_disp, + &clEnqueueAcquireD3D10ObjectsKHR_disp, + &clEnqueueReleaseD3D10ObjectsKHR_disp, +#else + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, +#endif + + /* OpenCL 1.1 */ + &clSetEventCallback_disp, + &clCreateSubBuffer_disp, + &clSetMemObjectDestructorCallback_disp, + &clCreateUserEvent_disp, + &clSetUserEventStatus_disp, + &clEnqueueReadBufferRect_disp, + &clEnqueueWriteBufferRect_disp, + &clEnqueueCopyBufferRect_disp, + + /* cl_ext_device_fission */ + &clCreateSubDevicesEXT_disp, + &clRetainDeviceEXT_disp, + &clReleaseDeviceEXT_disp, + + /* cl_khr_gl_event */ + &clCreateEventFromGLsyncKHR_disp, + + /* OpenCL 1.2 */ + &clCreateSubDevices_disp, + &clRetainDevice_disp, + &clReleaseDevice_disp, + &clCreateImage_disp, + &clCreateProgramWithBuiltInKernels_disp, + &clCompileProgram_disp, + &clLinkProgram_disp, + &clUnloadPlatformCompiler_disp, + &clGetKernelArgInfo_disp, + &clEnqueueFillBuffer_disp, + &clEnqueueFillImage_disp, + &clEnqueueMigrateMemObjects_disp, + &clEnqueueMarkerWithWaitList_disp, + &clEnqueueBarrierWithWaitList_disp, + &clGetExtensionFunctionAddressForPlatform_disp, + &clCreateFromGLTexture_disp, + + /* cl_khr_d3d11_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromD3D11KHR_disp, + &clCreateFromD3D11BufferKHR_disp, + &clCreateFromD3D11Texture2DKHR_disp, + &clCreateFromD3D11Texture3DKHR_disp, + &clCreateFromDX9MediaSurfaceKHR_disp, + &clEnqueueAcquireD3D11ObjectsKHR_disp, + &clEnqueueReleaseD3D11ObjectsKHR_disp, +#else + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, + NULL, +#endif + + /* cl_khr_dx9_media_sharing */ +#if defined(_WIN32) + &clGetDeviceIDsFromDX9MediaAdapterKHR_disp, + &clEnqueueAcquireDX9MediaSurfacesKHR_disp, + &clEnqueueReleaseDX9MediaSurfacesKHR_disp, +#else + NULL, + NULL, + NULL, +#endif + + /* cl_khr_egl_image */ + &clCreateFromEGLImageKHR_disp, + &clEnqueueAcquireEGLObjectsKHR_disp, + &clEnqueueReleaseEGLObjectsKHR_disp, + + /* cl_khr_egl_event */ + &clCreateEventFromEGLSyncKHR_disp, + + /* OpenCL 2.0 */ + &clCreateCommandQueueWithProperties_disp, + &clCreatePipe_disp, + &clGetPipeInfo_disp, + &clSVMAlloc_disp, + &clSVMFree_disp, + &clEnqueueSVMFree_disp, + &clEnqueueSVMMemcpy_disp, + &clEnqueueSVMMemFill_disp, + &clEnqueueSVMMap_disp, + &clEnqueueSVMUnmap_disp, + &clCreateSamplerWithProperties_disp, + &clSetKernelArgSVMPointer_disp, + &clSetKernelExecInfo_disp, + + /* cl_khr_sub_groups */ + &clGetKernelSubGroupInfoKHR_disp, + + /* OpenCL 2.1 */ + &clCloneKernel_disp, + &clCreateProgramWithIL_disp, + &clEnqueueSVMMigrateMem_disp, + &clGetDeviceAndHostTimer_disp, + &clGetHostTimer_disp, + &clGetKernelSubGroupInfo_disp, + &clSetDefaultDeviceCommandQueue_disp, + + /* OpenCL 2.2 */ + &clSetProgramReleaseCallback_disp, + &clSetProgramSpecializationConstant_disp, + + /* OpenCL 3.0 */ + &clCreateBufferWithProperties_disp, + &clCreateImageWithProperties_disp, + &clSetContextDestructorCallback_disp +}; +#endif // defined(CL_ENABLE_LAYERS) +#ifdef __cplusplus +} +#endif diff --git a/scripts/icd_print_layer_generated.c.mako b/scripts/icd_print_layer_generated.c.mako new file mode 100644 index 0000000..3ef38d5 --- /dev/null +++ b/scripts/icd_print_layer_generated.c.mako @@ -0,0 +1,310 @@ +/* + * Copyright (c) 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. + */ + +#include "icd_print_layer.h" + +/////////////////////////////////////////////////////////////////////////////// +// Core APIs: +%for apis in coreapis.values(): +%for api in apis: +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}, +% else: + ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix} +% endif +%endfor +{ +printf("${api.Name}\n"); +% if api.Name == "clSVMFree": +tdispatch->${api.Name}( +% else: +return tdispatch->${api.Name}( +% endif +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% else: + ${param.Name}); +% endif +%endfor +} + +/////////////////////////////////////////////////////////////////////////////// +%endfor +%endfor +<% +icdextensions = [ + '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' + ] +win32extensions = { + 'cl_khr_d3d10_sharing', + 'cl_khr_d3d11_sharing', + 'cl_khr_dx9_media_sharing', + } +%> +%for extension in icdextensions: +<% + apis = extapis[extension] +%>// ${extension} +%if extension in win32extensions: + +#if defined(_WIN32) +%endif +%for api in apis: +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}, +% else: + ${param.Type} ${param.Name}${param.TypeEnd}) ${api.Suffix} +% endif +%endfor +{ +printf("${api.Name}\n"); +return tdispatch->${api.Name}( +%for i, param in enumerate(api.Params): +% if i < len(api.Params)-1: + ${param.Name}, +% else: + ${param.Name}); +% endif +%endfor +} +%endfor + +%if extension in win32extensions: +#endif // defined(_WIN32) + +%endif +/////////////////////////////////////////////////////////////////////////////// + +%endfor +void _init_dispatch(void) { + dispatch.clGetPlatformIDs = &clGetPlatformIDs_wrap; + dispatch.clGetPlatformInfo = &clGetPlatformInfo_wrap; + dispatch.clGetDeviceIDs = &clGetDeviceIDs_wrap; + dispatch.clGetDeviceInfo = &clGetDeviceInfo_wrap; + dispatch.clCreateContext = &clCreateContext_wrap; + dispatch.clCreateContextFromType = &clCreateContextFromType_wrap; + dispatch.clRetainContext = &clRetainContext_wrap; + dispatch.clReleaseContext = &clReleaseContext_wrap; + dispatch.clGetContextInfo = &clGetContextInfo_wrap; + dispatch.clCreateCommandQueue = &clCreateCommandQueue_wrap; + dispatch.clRetainCommandQueue = &clRetainCommandQueue_wrap; + dispatch.clReleaseCommandQueue = &clReleaseCommandQueue_wrap; + dispatch.clGetCommandQueueInfo = &clGetCommandQueueInfo_wrap; + dispatch.clSetCommandQueueProperty = &clSetCommandQueueProperty_wrap; + dispatch.clCreateBuffer = &clCreateBuffer_wrap; + dispatch.clCreateImage2D = &clCreateImage2D_wrap; + dispatch.clCreateImage3D = &clCreateImage3D_wrap; + dispatch.clRetainMemObject = &clRetainMemObject_wrap; + dispatch.clReleaseMemObject = &clReleaseMemObject_wrap; + dispatch.clGetSupportedImageFormats = &clGetSupportedImageFormats_wrap; + dispatch.clGetMemObjectInfo = &clGetMemObjectInfo_wrap; + dispatch.clGetImageInfo = &clGetImageInfo_wrap; + dispatch.clCreateSampler = &clCreateSampler_wrap; + dispatch.clRetainSampler = &clRetainSampler_wrap; + dispatch.clReleaseSampler = &clReleaseSampler_wrap; + dispatch.clGetSamplerInfo = &clGetSamplerInfo_wrap; + dispatch.clCreateProgramWithSource = &clCreateProgramWithSource_wrap; + dispatch.clCreateProgramWithBinary = &clCreateProgramWithBinary_wrap; + dispatch.clRetainProgram = &clRetainProgram_wrap; + dispatch.clReleaseProgram = &clReleaseProgram_wrap; + dispatch.clBuildProgram = &clBuildProgram_wrap; + dispatch.clUnloadCompiler = &clUnloadCompiler_wrap; + dispatch.clGetProgramInfo = &clGetProgramInfo_wrap; + dispatch.clGetProgramBuildInfo = &clGetProgramBuildInfo_wrap; + dispatch.clCreateKernel = &clCreateKernel_wrap; + dispatch.clCreateKernelsInProgram = &clCreateKernelsInProgram_wrap; + dispatch.clRetainKernel = &clRetainKernel_wrap; + dispatch.clReleaseKernel = &clReleaseKernel_wrap; + dispatch.clSetKernelArg = &clSetKernelArg_wrap; + dispatch.clGetKernelInfo = &clGetKernelInfo_wrap; + dispatch.clGetKernelWorkGroupInfo = &clGetKernelWorkGroupInfo_wrap; + dispatch.clWaitForEvents = &clWaitForEvents_wrap; + dispatch.clGetEventInfo = &clGetEventInfo_wrap; + dispatch.clRetainEvent = &clRetainEvent_wrap; + dispatch.clReleaseEvent = &clReleaseEvent_wrap; + dispatch.clGetEventProfilingInfo = &clGetEventProfilingInfo_wrap; + dispatch.clFlush = &clFlush_wrap; + dispatch.clFinish = &clFinish_wrap; + dispatch.clEnqueueReadBuffer = &clEnqueueReadBuffer_wrap; + dispatch.clEnqueueWriteBuffer = &clEnqueueWriteBuffer_wrap; + dispatch.clEnqueueCopyBuffer = &clEnqueueCopyBuffer_wrap; + dispatch.clEnqueueReadImage = &clEnqueueReadImage_wrap; + dispatch.clEnqueueWriteImage = &clEnqueueWriteImage_wrap; + dispatch.clEnqueueCopyImage = &clEnqueueCopyImage_wrap; + dispatch.clEnqueueCopyImageToBuffer = &clEnqueueCopyImageToBuffer_wrap; + dispatch.clEnqueueCopyBufferToImage = &clEnqueueCopyBufferToImage_wrap; + dispatch.clEnqueueMapBuffer = &clEnqueueMapBuffer_wrap; + dispatch.clEnqueueMapImage = &clEnqueueMapImage_wrap; + dispatch.clEnqueueUnmapMemObject = &clEnqueueUnmapMemObject_wrap; + dispatch.clEnqueueNDRangeKernel = &clEnqueueNDRangeKernel_wrap; + dispatch.clEnqueueTask = &clEnqueueTask_wrap; + dispatch.clEnqueueNativeKernel = &clEnqueueNativeKernel_wrap; + dispatch.clEnqueueMarker = &clEnqueueMarker_wrap; + dispatch.clEnqueueWaitForEvents = &clEnqueueWaitForEvents_wrap; + dispatch.clEnqueueBarrier = &clEnqueueBarrier_wrap; + dispatch.clGetExtensionFunctionAddress = &clGetExtensionFunctionAddress_wrap; + dispatch.clCreateFromGLBuffer = &clCreateFromGLBuffer_wrap; + dispatch.clCreateFromGLTexture2D = &clCreateFromGLTexture2D_wrap; + dispatch.clCreateFromGLTexture3D = &clCreateFromGLTexture3D_wrap; + dispatch.clCreateFromGLRenderbuffer = &clCreateFromGLRenderbuffer_wrap; + dispatch.clGetGLObjectInfo = &clGetGLObjectInfo_wrap; + dispatch.clGetGLTextureInfo = &clGetGLTextureInfo_wrap; + dispatch.clEnqueueAcquireGLObjects = &clEnqueueAcquireGLObjects_wrap; + dispatch.clEnqueueReleaseGLObjects = &clEnqueueReleaseGLObjects_wrap; + dispatch.clGetGLContextInfoKHR = &clGetGLContextInfoKHR_wrap; + + /* cl_khr_d3d10_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromD3D10KHR = &clGetDeviceIDsFromD3D10KHR_wrap; + dispatch.clCreateFromD3D10BufferKHR = &clCreateFromD3D10BufferKHR_wrap; + dispatch.clCreateFromD3D10Texture2DKHR = &clCreateFromD3D10Texture2DKHR_wrap; + dispatch.clCreateFromD3D10Texture3DKHR = &clCreateFromD3D10Texture3DKHR_wrap; + dispatch.clEnqueueAcquireD3D10ObjectsKHR = &clEnqueueAcquireD3D10ObjectsKHR_wrap; + dispatch.clEnqueueReleaseD3D10ObjectsKHR = &clEnqueueReleaseD3D10ObjectsKHR_wrap; +#else + dispatch.clGetDeviceIDsFromD3D10KHR = NULL; + dispatch.clCreateFromD3D10BufferKHR = NULL; + dispatch.clCreateFromD3D10Texture2DKHR = NULL; + dispatch.clCreateFromD3D10Texture3DKHR = NULL; + dispatch.clEnqueueAcquireD3D10ObjectsKHR = NULL; + dispatch.clEnqueueReleaseD3D10ObjectsKHR = NULL; +#endif + + /* OpenCL 1.1 */ + dispatch.clSetEventCallback = &clSetEventCallback_wrap; + dispatch.clCreateSubBuffer = &clCreateSubBuffer_wrap; + dispatch.clSetMemObjectDestructorCallback = &clSetMemObjectDestructorCallback_wrap; + dispatch.clCreateUserEvent = &clCreateUserEvent_wrap; + dispatch.clSetUserEventStatus = &clSetUserEventStatus_wrap; + dispatch.clEnqueueReadBufferRect = &clEnqueueReadBufferRect_wrap; + dispatch.clEnqueueWriteBufferRect = &clEnqueueWriteBufferRect_wrap; + dispatch.clEnqueueCopyBufferRect = &clEnqueueCopyBufferRect_wrap; + + /* cl_ext_device_fission */ + dispatch.clCreateSubDevicesEXT = &clCreateSubDevicesEXT_wrap; + dispatch.clRetainDeviceEXT = &clRetainDeviceEXT_wrap; + dispatch.clReleaseDeviceEXT = &clReleaseDeviceEXT_wrap; + + /* cl_khr_gl_event */ + dispatch.clCreateEventFromGLsyncKHR = &clCreateEventFromGLsyncKHR_wrap; + + /* OpenCL 1.2 */ + dispatch.clCreateSubDevices = &clCreateSubDevices_wrap; + dispatch.clRetainDevice = &clRetainDevice_wrap; + dispatch.clReleaseDevice = &clReleaseDevice_wrap; + dispatch.clCreateImage = &clCreateImage_wrap; + dispatch.clCreateProgramWithBuiltInKernels = &clCreateProgramWithBuiltInKernels_wrap; + dispatch.clCompileProgram = &clCompileProgram_wrap; + dispatch.clLinkProgram = &clLinkProgram_wrap; + dispatch.clUnloadPlatformCompiler = &clUnloadPlatformCompiler_wrap; + dispatch.clGetKernelArgInfo = &clGetKernelArgInfo_wrap; + dispatch.clEnqueueFillBuffer = &clEnqueueFillBuffer_wrap; + dispatch.clEnqueueFillImage = &clEnqueueFillImage_wrap; + dispatch.clEnqueueMigrateMemObjects = &clEnqueueMigrateMemObjects_wrap; + dispatch.clEnqueueMarkerWithWaitList = &clEnqueueMarkerWithWaitList_wrap; + dispatch.clEnqueueBarrierWithWaitList = &clEnqueueBarrierWithWaitList_wrap; + dispatch.clGetExtensionFunctionAddressForPlatform = &clGetExtensionFunctionAddressForPlatform_wrap; + dispatch.clCreateFromGLTexture = &clCreateFromGLTexture_wrap; + + /* cl_khr_d3d11_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromD3D11KHR = &clGetDeviceIDsFromD3D11KHR_wrap; + dispatch.clCreateFromD3D11BufferKHR = &clCreateFromD3D11BufferKHR_wrap; + dispatch.clCreateFromD3D11Texture2DKHR = &clCreateFromD3D11Texture2DKHR_wrap; + dispatch.clCreateFromD3D11Texture3DKHR = &clCreateFromD3D11Texture3DKHR_wrap; + dispatch.clCreateFromDX9MediaSurfaceKHR = &clCreateFromDX9MediaSurfaceKHR_wrap; + dispatch.clEnqueueAcquireD3D11ObjectsKHR = &clEnqueueAcquireD3D11ObjectsKHR_wrap; + dispatch.clEnqueueReleaseD3D11ObjectsKHR = &clEnqueueReleaseD3D11ObjectsKHR_wrap; +#else + dispatch.clGetDeviceIDsFromD3D11KHR = NULL; + dispatch.clCreateFromD3D11BufferKHR = NULL; + dispatch.clCreateFromD3D11Texture2DKHR = NULL; + dispatch.clCreateFromD3D11Texture3DKHR = NULL; + dispatch.clCreateFromDX9MediaSurfaceKHR = NULL; + dispatch.clEnqueueAcquireD3D11ObjectsKHR = NULL; + dispatch.clEnqueueReleaseD3D11ObjectsKHR = NULL; +#endif + + /* cl_khr_dx9_media_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = &clGetDeviceIDsFromDX9MediaAdapterKHR_wrap; + dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = &clEnqueueAcquireDX9MediaSurfacesKHR_wrap; + dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = &clEnqueueReleaseDX9MediaSurfacesKHR_wrap; +#else + dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = NULL; + dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = NULL; + dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = NULL; +#endif + + /* cl_khr_egl_image */ + dispatch.clCreateFromEGLImageKHR = &clCreateFromEGLImageKHR_wrap; + dispatch.clEnqueueAcquireEGLObjectsKHR = &clEnqueueAcquireEGLObjectsKHR_wrap; + dispatch.clEnqueueReleaseEGLObjectsKHR = &clEnqueueReleaseEGLObjectsKHR_wrap; + + /* cl_khr_egl_event */ + dispatch.clCreateEventFromEGLSyncKHR = &clCreateEventFromEGLSyncKHR_wrap; + + /* OpenCL 2.0 */ + dispatch.clCreateCommandQueueWithProperties = &clCreateCommandQueueWithProperties_wrap; + dispatch.clCreatePipe = &clCreatePipe_wrap; + dispatch.clGetPipeInfo = &clGetPipeInfo_wrap; + dispatch.clSVMAlloc = &clSVMAlloc_wrap; + dispatch.clSVMFree = &clSVMFree_wrap; + dispatch.clEnqueueSVMFree = &clEnqueueSVMFree_wrap; + dispatch.clEnqueueSVMMemcpy = &clEnqueueSVMMemcpy_wrap; + dispatch.clEnqueueSVMMemFill = &clEnqueueSVMMemFill_wrap; + dispatch.clEnqueueSVMMap = &clEnqueueSVMMap_wrap; + dispatch.clEnqueueSVMUnmap = &clEnqueueSVMUnmap_wrap; + dispatch.clCreateSamplerWithProperties = &clCreateSamplerWithProperties_wrap; + dispatch.clSetKernelArgSVMPointer = &clSetKernelArgSVMPointer_wrap; + dispatch.clSetKernelExecInfo = &clSetKernelExecInfo_wrap; + + /* cl_khr_sub_groups */ + dispatch.clGetKernelSubGroupInfoKHR = &clGetKernelSubGroupInfoKHR_wrap; + + /* OpenCL 2.1 */ + dispatch.clCloneKernel = &clCloneKernel_wrap; + dispatch.clCreateProgramWithIL = &clCreateProgramWithIL_wrap; + dispatch.clEnqueueSVMMigrateMem = &clEnqueueSVMMigrateMem_wrap; + dispatch.clGetDeviceAndHostTimer = &clGetDeviceAndHostTimer_wrap; + dispatch.clGetHostTimer = &clGetHostTimer_wrap; + dispatch.clGetKernelSubGroupInfo = &clGetKernelSubGroupInfo_wrap; + dispatch.clSetDefaultDeviceCommandQueue = &clSetDefaultDeviceCommandQueue_wrap; + + /* OpenCL 2.2 */ + dispatch.clSetProgramReleaseCallback = &clSetProgramReleaseCallback_wrap; + dispatch.clSetProgramSpecializationConstant = &clSetProgramSpecializationConstant_wrap; + + /* OpenCL 3.0 */ + dispatch.clCreateBufferWithProperties = &clCreateBufferWithProperties_wrap; + dispatch.clCreateImageWithProperties = &clCreateImageWithProperties_wrap; + dispatch.clSetContextDestructorCallback = &clSetContextDestructorCallback_wrap; +} diff --git a/scripts/icdloadergenerator.py b/scripts/icdloadergenerator.py new file mode 100755 index 0000000..012bff6 --- /dev/null +++ b/scripts/icdloadergenerator.py @@ -0,0 +1,77 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER 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. +""" + +import os +import os.path as path +import re +from androidbpgenerator import INDENT, CCDefaults, ModuleInfo, Generator, NOVERBOSE + +RUN_CALLABLE = True + + +class ICDLoaderGenerator(Generator): + def __init__(self, root): + # It is necessary that patching on LLVM before generating Android.bp + self.proj = path.join(root, "OpenCL-ICD-Loader/") + super(ICDLoaderGenerator, self).__init__(self.proj, root) + + self.allmoduleinfo[0] = ModuleInfo("libOpenCL", "libOpenCL.bp", "CMakeFiles/OpenCL.dir/", + "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[1] = ModuleInfo("libIcdLog", "libIcdLog.bp", "test/log/CMakeFiles/IcdLog.dir/", + "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[2] = ModuleInfo("libOpenCLDriverStub", "libOpenCLDriverStub.bp", + "test/driver_stub/CMakeFiles/OpenCLDriverStub.dir/", "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[3] = ModuleInfo("icd_loader_test", "icd_loader_test.bp", + "test/loader_test/CMakeFiles/icd_loader_test.dir/", "binary", "OpenCL-ICD-Loader-defaults") + + self.allmoduledefaults = CCDefaults(self.proj, "OpenCL-ICD-Loader-defaults", + cflags = ["-Wno-error", "-Wno-error=implicit-function-declaration", "-DAMD64"], + cppflags = ["-D__ANDROID__"], + clang_cflags = ["-Wno-error=non-virtual-dtor"], + include_dirs = ["hardware/intel/external/opencl/compute-runtime/third_party/opencl_headers"], + bpfiles = ["libOpenCL.bp", "libIcdLog.bp", "libOpenCLDriverStub.bp", "icd_loader_test.bp"], ) + + def getTemplate(self): + return "icd-loader.tpl" + + def adjustSources(self, mode, all_sources): + for i, l in enumerate(all_sources): + all_sources[i] = INDENT * 2 + "\"" + re.sub(r".*?: " + self.allmoduleinfo[mode].Mid_Dir, "", + re.sub("CMakeFiles/.*?\\.dir/", "", l.replace("__/", "../"))) + + +class Main: + + def run(self): + script = path.dirname(__file__) + root = path.abspath(path.join(script, "../..")) + + print(("script = " + script)) + print(("root = " + root)) + + ICDLoaderGenerator(root).generate() + + +if RUN_CALLABLE: + m = Main() + m.run() \ No newline at end of file diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index a158995..0d78a79 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -3,5 +3,45 @@ include_directories (./inc) add_subdirectory (log) add_subdirectory (driver_stub) add_subdirectory (loader_test) +if (ENABLE_OPENCL_LAYERS) + add_subdirectory (layer) +endif () -add_test (NAME opencl_icd_loader_test COMMAND icd_loader_test) +set_target_properties (IcdLog OpenCLDriverStub icd_loader_test + PROPERTIES + ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" + PDB_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" +) +add_test ( + NAME opencl_icd_loader_test + COMMAND icd_loader_test +) + +if (ENABLE_OPENCL_LAYERINFO) + add_test ( + NAME cllayerinfo_test + COMMAND cllayerinfo + ) +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 OPENCL_LAYERS=$ + WORKING_DIRECTORY "${TEST_WORKING_DIRECTORY}" + ) +endif() diff --git a/test/driver_stub/CMakeLists.txt b/test/driver_stub/CMakeLists.txt index 47b3bd2..e3b0ebf 100644 --- a/test/driver_stub/CMakeLists.txt +++ b/test/driver_stub/CMakeLists.txt @@ -5,6 +5,8 @@ if (NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") list (APPEND OPENCL_DRIVER_STUB_SOURCES driver_stub.def) endif () -add_library (OpenCLDriverStub ${OPENCL_DRIVER_STUB_SOURCES}) +add_library (OpenCLDriverStub SHARED ${OPENCL_DRIVER_STUB_SOURCES}) -target_link_libraries (OpenCLDriverStub IcdLog) +target_link_libraries (OpenCLDriverStub IcdLog OpenCL::Headers) + +target_compile_definitions (OpenCLDriverStub PRIVATE CL_TARGET_OPENCL_VERSION=300) diff --git a/test/driver_stub/cl.c b/test/driver_stub/cl.c index 8021923..398fee8 100644 --- a/test/driver_stub/cl.c +++ b/test/driver_stub/cl.c @@ -171,7 +171,7 @@ clGetDeviceIDs(cl_platform_id platform, { cl_int ret = CL_SUCCESS; - if ((num_entries > 1 || num_entries < 0) && devices != NULL) { + if ((num_entries > 1) && devices != NULL) { ret = CL_INVALID_VALUE; goto done; } @@ -355,6 +355,26 @@ clGetContextInfo(cl_context context, return return_value; } +CL_API_ENTRY cl_int CL_API_CALL +clSetContextDestructorCallback(cl_context context, + void (CL_CALLBACK* pfn_notify)(cl_context context, + void* user_data), + void* user_data) CL_API_SUFFIX__VERSION_3_0 +{ + cl_int return_value = CL_OUT_OF_RESOURCES; + test_icd_stub_log("clSetContextDestructorCallback(%p, %p, %p)\n", + context, + pfn_notify, + user_data); + pfn_notify(context, user_data); + test_icd_stub_log("setcontextdestructor_callback(%p, %p)\n", + context, + user_data); + + test_icd_stub_log("Value returned: %d\n", return_value); + return return_value; +} + /* Command Queue APIs */ CL_API_ENTRY cl_command_queue CL_API_CALL clCreateCommandQueue(cl_context context, @@ -378,7 +398,7 @@ CL_API_ENTRY cl_int CL_API_CALL clSetCommandQueueProperty(cl_command_queue command_queue , cl_command_queue_properties properties , cl_bool enable , - cl_command_queue_properties * old_properties) CL_EXT_SUFFIX__VERSION_1_0_DEPRECATED + cl_command_queue_properties * old_properties) CL_API_SUFFIX__VERSION_1_0_DEPRECATED { cl_int return_value = CL_OUT_OF_RESOURCES; test_icd_stub_log("clSetCommandQueueProperty(%p, %p, %u, %p)\n", @@ -551,6 +571,52 @@ clCreateImage3D(cl_context context, return obj; } +CL_API_ENTRY cl_mem CL_API_CALL +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 +{ + cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem)); + obj->dispatch = dispatchTable; + test_icd_stub_log("clCreateBufferWithProperties(%p, %p, %x, %u, %p, %p)\n", + context, + properties, + flags, + size, + host_ptr, + errcode_ret); + + test_icd_stub_log("Value returned: %p\n", obj); + return obj; +} + +CL_API_ENTRY cl_mem CL_API_CALL +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 +{ + cl_mem obj = (cl_mem) malloc(sizeof(struct _cl_mem)); + obj->dispatch = dispatchTable; + test_icd_stub_log("clCreateImageWithProperties(%p, %p, %x, %p, %p, %p, %p)\n", + context, + properties, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); + + test_icd_stub_log("Value returned: %p\n", obj); + return obj; +} + CL_API_ENTRY cl_int CL_API_CALL clRetainMemObject(cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 { @@ -639,10 +705,10 @@ clSetMemObjectDestructorCallback(cl_mem memobj , memobj, pfn_notify, user_data); - pfn_notify(memobj, NULL); + pfn_notify(memobj, user_data); test_icd_stub_log("setmemobjectdestructor_callback(%p, %p)\n", memobj, - NULL); + user_data); test_icd_stub_log("Value returned: %d\n", return_value); return return_value; @@ -836,6 +902,7 @@ clCompileProgram(cl_program program , void (CL_CALLBACK * pfn_notify)(cl_program program , void * user_data), void * user_data) CL_API_SUFFIX__VERSION_1_2 { + (void)input_headers; cl_int return_value = CL_OUT_OF_RESOURCES; test_icd_stub_log("clCompileProgram(%p, %u, %p, %p, %u, %p, %p, %p)\n", program, @@ -1768,11 +1835,13 @@ clEnqueueNativeKernel(cl_command_queue command_queue , return return_value; } +static void extFunc(void) { } + CL_API_ENTRY void * CL_API_CALL clGetExtensionFunctionAddressForPlatform(cl_platform_id platform , 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); diff --git a/test/driver_stub/cl_ext.c b/test/driver_stub/cl_ext.c index ece0c59..4a5c38b 100644 --- a/test/driver_stub/cl_ext.c +++ b/test/driver_stub/cl_ext.c @@ -10,7 +10,7 @@ struct driverStubextFunc_st void *func; }; -#define EXT_FUNC(name) { #name, (void*)(name) } +#define EXT_FUNC(name) { #name, (void*)(intptr_t)(name) } static struct driverStubextFunc_st clExtensions[] = { diff --git a/test/driver_stub/cl_gl.c b/test/driver_stub/cl_gl.c index 3cc5cbb..e195463 100644 --- a/test/driver_stub/cl_gl.c +++ b/test/driver_stub/cl_gl.c @@ -1,5 +1,4 @@ #include -#include #include // Need to rename all CL API functions to prevent ICD loader functions calling @@ -207,7 +206,7 @@ clGetGLContextInfoKHR(const cl_context_properties * properties, CL_API_ENTRY cl_event CL_API_CALL clCreateEventFromGLsyncKHR(cl_context context , cl_GLsync cl_GLsync , - cl_int * errcode_ret ) CL_EXT_SUFFIX__VERSION_1_1 + cl_int * errcode_ret ) CL_API_SUFFIX__VERSION_1_1 { cl_event ret_event = (cl_event)(SIZE_T_MAX); diff --git a/test/driver_stub/icd.c b/test/driver_stub/icd.c index d2b1b2b..3f12d77 100644 --- a/test/driver_stub/icd.c +++ b/test/driver_stub/icd.c @@ -7,6 +7,9 @@ #define CL_USE_DEPRECATED_OPENCL_1_0_APIS #define CL_USE_DEPRECATED_OPENCL_1_1_APIS #define CL_USE_DEPRECATED_OPENCL_1_2_APIS +#define CL_USE_DEPRECATED_OPENCL_2_0_APIS +#define CL_USE_DEPRECATED_OPENCL_2_1_APIS +#define CL_USE_DEPRECATED_OPENCL_2_2_APIS // Need to rename all CL API functions to prevent ICD loader functions calling // themselves via the dispatch table. Include this before cl headers. @@ -14,7 +17,6 @@ #include "CL/cl.h" #include "CL/cl_gl.h" -#include "CL/cl_gl_ext.h" /* * Prototypes for deprecated functions no longer present in cl.h @@ -27,7 +29,7 @@ clSetCommandQueueProperty(cl_command_queue /* command_queue */, #define ICD_DISPATCH_TABLE_ENTRY(fn) \ assert(dispatchTable->entryCount < 256); \ - dispatchTable->entries[dispatchTable->entryCount++] = (void*)(fn) + dispatchTable->entries[dispatchTable->entryCount++] = (void*)(intptr_t)(fn) cl_int cliIcdDispatchTableCreate(CLIicdDispatchTable **outDispatchTable) { @@ -148,12 +150,15 @@ cl_int cliIcdDispatchTableCreate(CLIicdDispatchTable **outDispatchTable) ICD_DISPATCH_TABLE_ENTRY ( clEnqueueWriteBufferRect); ICD_DISPATCH_TABLE_ENTRY ( clEnqueueCopyBufferRect); + /* cl_ext_device_fission */ ICD_DISPATCH_TABLE_ENTRY ( /*clCreateSubDevicesEXT*/NULL); ICD_DISPATCH_TABLE_ENTRY ( /*clRetainDeviceEXT*/ NULL); ICD_DISPATCH_TABLE_ENTRY ( /*clReleaseDevice*/NULL); + /* cl_khr_gl_event */ ICD_DISPATCH_TABLE_ENTRY ( clCreateEventFromGLsyncKHR); + /* OpenCL 1.2 */ ICD_DISPATCH_TABLE_ENTRY ( clCreateSubDevices); ICD_DISPATCH_TABLE_ENTRY ( clRetainDevice); ICD_DISPATCH_TABLE_ENTRY ( clReleaseDevice); @@ -171,6 +176,64 @@ cl_int cliIcdDispatchTableCreate(CLIicdDispatchTable **outDispatchTable) ICD_DISPATCH_TABLE_ENTRY ( clGetExtensionFunctionAddressForPlatform); ICD_DISPATCH_TABLE_ENTRY ( clCreateFromGLTexture); + /* cl_khr_d3d11_sharing */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* cl_khr_dx9_media_sharing */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* cl_khr_egl_image */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* cl_khr_egl_event */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* OpenCL 2.0 */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* cl_khr_sub_groups */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* OpenCL 2.1 */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* OpenCL 2.2 */ + ICD_DISPATCH_TABLE_ENTRY( NULL ); + ICD_DISPATCH_TABLE_ENTRY( NULL ); + + /* OpenCL 3.0 */ + ICD_DISPATCH_TABLE_ENTRY ( clCreateBufferWithProperties ); + ICD_DISPATCH_TABLE_ENTRY ( clCreateImageWithProperties ); + ICD_DISPATCH_TABLE_ENTRY ( clSetContextDestructorCallback ); + // return success *outDispatchTable = dispatchTable; return CL_SUCCESS; diff --git a/test/driver_stub/rename_api.h b/test/driver_stub/rename_api.h index 7d5130c..555695d 100644 --- a/test/driver_stub/rename_api.h +++ b/test/driver_stub/rename_api.h @@ -102,5 +102,8 @@ #define clEnqueueReleaseGLObjects ___clEnqueueReleaseGLObjects #define clGetGLContextInfoKHR ___clGetGLContextInfoKHR #define clCreateEventFromGLsyncKHR ___clCreateEventFromGLsyncKHR +#define clCreateBufferWithProperties ___clCreateBufferWithProperties +#define clCreateImageWithProperties ___clCreateImageWithProperties +#define clSetContextDestructorCallback ___clSetContextDestructorCallback #endif /* __RENAME_API_H__ */ diff --git a/test/inc/platform/icd_test_log.h b/test/inc/platform/icd_test_log.h index 6db0bfe..1847ef3 100644 --- a/test/inc/platform/icd_test_log.h +++ b/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/test/layer/CMakeLists.txt b/test/layer/CMakeLists.txt new file mode 100644 index 0000000..ea4e0e4 --- /dev/null +++ b/test/layer/CMakeLists.txt @@ -0,0 +1,22 @@ +set (OPENCL_PRINT_LAYER_SOURCES + icd_print_layer.c + icd_print_layer.h + icd_print_layer_generated.c) + +if (WIN32) + list (APPEND OPENCL_PRINT_LAYER_SOURCES icd_print_layer.def) +else () + if (NOT APPLE) + list (APPEND OPENCL_PRINT_LAYER_SOURCES icd_print_layer.map) + endif () +endif () + +add_library (PrintLayer SHARED ${OPENCL_PRINT_LAYER_SOURCES}) + +target_include_directories(PrintLayer PRIVATE ${PARENT_DIR}/include) +target_link_libraries(PrintLayer PUBLIC OpenCL::Headers) +target_compile_definitions (PrintLayer PRIVATE CL_TARGET_OPENCL_VERSION=300) + +if (NOT WIN32 AND NOT APPLE) + set_target_properties (PrintLayer PROPERTIES LINK_FLAGS "-Wl,--version-script -Wl,${CMAKE_CURRENT_SOURCE_DIR}/icd_print_layer.map") +endif () diff --git a/test/layer/icd_print_layer.c b/test/layer/icd_print_layer.c new file mode 100644 index 0000000..d8bf462 --- /dev/null +++ b/test/layer/icd_print_layer.c @@ -0,0 +1,92 @@ +/* + * Copyright (c) 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. + */ + +#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: + sz = sizeof(api_version); + src = &api_version; + break; + case CL_LAYER_NAME: + sz = sizeof(name); + src = name; + break; + default: + return CL_INVALID_VALUE; + } + return set_param_value(param_value_size, param_value, param_value_size_ret, sz, src); +} + +CL_API_ENTRY cl_int CL_API_CALL +clInitLayer( + cl_uint num_entries, + 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)) + return CL_INVALID_VALUE; + + _init_dispatch(); + + tdispatch = target_dispatch; + *layer_dispatch_ret = &dispatch; + *num_entries_out = sizeof(dispatch)/sizeof(dispatch.clGetPlatformIDs); + + return CL_SUCCESS; +} + + diff --git a/test/layer/icd_print_layer.def b/test/layer/icd_print_layer.def new file mode 100644 index 0000000..c33a80b --- /dev/null +++ b/test/layer/icd_print_layer.def @@ -0,0 +1,3 @@ +EXPORTS +clGetLayerInfo +clInitLayer diff --git a/test/layer/icd_print_layer.h b/test/layer/icd_print_layer.h new file mode 100644 index 0000000..6c73fe6 --- /dev/null +++ b/test/layer/icd_print_layer.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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_PRINT_LAYER_H +#define __ICD_PRINT_LAYER_H + +#ifndef CL_USE_DEPRECATED_OPENCL_1_0_APIS +#define CL_USE_DEPRECATED_OPENCL_1_0_APIS +#endif + +#ifndef CL_USE_DEPRECATED_OPENCL_1_1_APIS +#define CL_USE_DEPRECATED_OPENCL_1_1_APIS +#endif + +#ifndef CL_USE_DEPRECATED_OPENCL_1_2_APIS +#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 + +#ifdef __cplusplus +extern "C" { +#endif + +extern struct _cl_icd_dispatch dispatch; + +extern const struct _cl_icd_dispatch *tdispatch; + +extern void _init_dispatch(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __ICD_PRINT_LAYER_H */ diff --git a/test/layer/icd_print_layer.map b/test/layer/icd_print_layer.map new file mode 100644 index 0000000..b32d582 --- /dev/null +++ b/test/layer/icd_print_layer.map @@ -0,0 +1,8 @@ +{ + global: +clGetLayerInfo; +clInitLayer; + + local: + *; +}; diff --git a/test/layer/icd_print_layer_generated.c b/test/layer/icd_print_layer_generated.c new file mode 100644 index 0000000..ee9d19e --- /dev/null +++ b/test/layer/icd_print_layer_generated.c @@ -0,0 +1,2746 @@ +/* + * Copyright (c) 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. + */ + +#include "icd_print_layer.h" + +/////////////////////////////////////////////////////////////////////////////// +// Core APIs: +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 +{ +printf("clGetPlatformIDs\n"); +return tdispatch->clGetPlatformIDs( + num_entries, + platforms, + num_platforms); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetPlatformInfo_wrap( + 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 +{ +printf("clGetPlatformInfo\n"); +return tdispatch->clGetPlatformInfo( + platform, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetDeviceIDs_wrap( + 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 +{ +printf("clGetDeviceIDs\n"); +return tdispatch->clGetDeviceIDs( + platform, + device_type, + num_entries, + devices, + num_devices); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetDeviceInfo_wrap( + 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 +{ +printf("clGetDeviceInfo\n"); +return tdispatch->clGetDeviceInfo( + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_context CL_API_CALL clCreateContext_wrap( + 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) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateContext\n"); +return tdispatch->clCreateContext( + properties, + num_devices, + devices, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +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), + void* user_data, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateContextFromType\n"); +return tdispatch->clCreateContextFromType( + properties, + device_type, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainContext_wrap( + cl_context context) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainContext\n"); +return tdispatch->clRetainContext( + context); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseContext_wrap( + cl_context context) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseContext\n"); +return tdispatch->clReleaseContext( + context); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetContextInfo_wrap( + 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 +{ +printf("clGetContextInfo\n"); +return tdispatch->clGetContextInfo( + context, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainCommandQueue_wrap( + cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainCommandQueue\n"); +return tdispatch->clRetainCommandQueue( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseCommandQueue_wrap( + cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseCommandQueue\n"); +return tdispatch->clReleaseCommandQueue( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetCommandQueueInfo_wrap( + 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 +{ +printf("clGetCommandQueueInfo\n"); +return tdispatch->clGetCommandQueueInfo( + command_queue, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateBuffer_wrap( + cl_context context, + cl_mem_flags flags, + size_t size, + void* host_ptr, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateBuffer\n"); +return tdispatch->clCreateBuffer( + context, + flags, + size, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainMemObject_wrap( + cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainMemObject\n"); +return tdispatch->clRetainMemObject( + memobj); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseMemObject_wrap( + cl_mem memobj) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseMemObject\n"); +return tdispatch->clReleaseMemObject( + memobj); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetSupportedImageFormats_wrap( + 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 +{ +printf("clGetSupportedImageFormats\n"); +return tdispatch->clGetSupportedImageFormats( + context, + flags, + image_type, + num_entries, + image_formats, + num_image_formats); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetMemObjectInfo_wrap( + 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 +{ +printf("clGetMemObjectInfo\n"); +return tdispatch->clGetMemObjectInfo( + memobj, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetImageInfo_wrap( + 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 +{ +printf("clGetImageInfo\n"); +return tdispatch->clGetImageInfo( + image, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainSampler_wrap( + cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainSampler\n"); +return tdispatch->clRetainSampler( + sampler); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseSampler_wrap( + cl_sampler sampler) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseSampler\n"); +return tdispatch->clReleaseSampler( + sampler); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetSamplerInfo_wrap( + 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 +{ +printf("clGetSamplerInfo\n"); +return tdispatch->clGetSamplerInfo( + sampler, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_program CL_API_CALL clCreateProgramWithSource_wrap( + cl_context context, + cl_uint count, + const char** strings, + const size_t* lengths, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateProgramWithSource\n"); +return tdispatch->clCreateProgramWithSource( + context, + count, + strings, + lengths, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_program CL_API_CALL clCreateProgramWithBinary_wrap( + 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 +{ +printf("clCreateProgramWithBinary\n"); +return tdispatch->clCreateProgramWithBinary( + context, + num_devices, + device_list, + lengths, + binaries, + binary_status, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainProgram_wrap( + cl_program program) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainProgram\n"); +return tdispatch->clRetainProgram( + program); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseProgram_wrap( + cl_program program) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseProgram\n"); +return tdispatch->clReleaseProgram( + program); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clBuildProgram_wrap( + 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 +{ +printf("clBuildProgram\n"); +return tdispatch->clBuildProgram( + program, + num_devices, + device_list, + options, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetProgramInfo_wrap( + 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 +{ +printf("clGetProgramInfo\n"); +return tdispatch->clGetProgramInfo( + program, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetProgramBuildInfo_wrap( + 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 +{ +printf("clGetProgramBuildInfo\n"); +return tdispatch->clGetProgramBuildInfo( + program, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clCreateKernel\n"); +return tdispatch->clCreateKernel( + program, + kernel_name, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clCreateKernelsInProgram_wrap( + cl_program program, + cl_uint num_kernels, + cl_kernel* kernels, + cl_uint* num_kernels_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateKernelsInProgram\n"); +return tdispatch->clCreateKernelsInProgram( + program, + num_kernels, + kernels, + num_kernels_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainKernel_wrap( + cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainKernel\n"); +return tdispatch->clRetainKernel( + kernel); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseKernel_wrap( + cl_kernel kernel) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseKernel\n"); +return tdispatch->clReleaseKernel( + kernel); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clSetKernelArg_wrap( + cl_kernel kernel, + cl_uint arg_index, + size_t arg_size, + const void* arg_value) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clSetKernelArg\n"); +return tdispatch->clSetKernelArg( + kernel, + arg_index, + arg_size, + arg_value); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetKernelInfo_wrap( + 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 +{ +printf("clGetKernelInfo\n"); +return tdispatch->clGetKernelInfo( + kernel, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetKernelWorkGroupInfo_wrap( + 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 +{ +printf("clGetKernelWorkGroupInfo\n"); +return tdispatch->clGetKernelWorkGroupInfo( + kernel, + device, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clWaitForEvents_wrap( + cl_uint num_events, + const cl_event* event_list) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clWaitForEvents\n"); +return tdispatch->clWaitForEvents( + num_events, + event_list); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetEventInfo_wrap( + 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 +{ +printf("clGetEventInfo\n"); +return tdispatch->clGetEventInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainEvent_wrap( + cl_event event) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clRetainEvent\n"); +return tdispatch->clRetainEvent( + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseEvent_wrap( + cl_event event) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clReleaseEvent\n"); +return tdispatch->clReleaseEvent( + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetEventProfilingInfo_wrap( + 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 +{ +printf("clGetEventProfilingInfo\n"); +return tdispatch->clGetEventProfilingInfo( + event, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clFlush_wrap( + cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clFlush\n"); +return tdispatch->clFlush( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clFinish_wrap( + cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clFinish\n"); +return tdispatch->clFinish( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueReadBuffer_wrap( + 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) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clEnqueueReadBuffer\n"); +return tdispatch->clEnqueueReadBuffer( + command_queue, + buffer, + blocking_read, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueWriteBuffer_wrap( + 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) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clEnqueueWriteBuffer\n"); +return tdispatch->clEnqueueWriteBuffer( + command_queue, + buffer, + blocking_write, + offset, + size, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueCopyBuffer_wrap( + 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) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clEnqueueCopyBuffer\n"); +return tdispatch->clEnqueueCopyBuffer( + command_queue, + src_buffer, + dst_buffer, + src_offset, + dst_offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueReadImage_wrap( + 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 +{ +printf("clEnqueueReadImage\n"); +return tdispatch->clEnqueueReadImage( + command_queue, + image, + blocking_read, + origin, + region, + row_pitch, + slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueWriteImage_wrap( + 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 +{ +printf("clEnqueueWriteImage\n"); +return tdispatch->clEnqueueWriteImage( + command_queue, + image, + blocking_write, + origin, + region, + input_row_pitch, + input_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueCopyImage_wrap( + 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 +{ +printf("clEnqueueCopyImage\n"); +return tdispatch->clEnqueueCopyImage( + command_queue, + src_image, + dst_image, + src_origin, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueCopyImageToBuffer_wrap( + 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 +{ +printf("clEnqueueCopyImageToBuffer\n"); +return tdispatch->clEnqueueCopyImageToBuffer( + command_queue, + src_image, + dst_buffer, + src_origin, + region, + dst_offset, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueCopyBufferToImage_wrap( + 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 +{ +printf("clEnqueueCopyBufferToImage\n"); +return tdispatch->clEnqueueCopyBufferToImage( + command_queue, + src_buffer, + dst_image, + src_offset, + dst_origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static void* CL_API_CALL clEnqueueMapBuffer_wrap( + 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) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clEnqueueMapBuffer\n"); +return tdispatch->clEnqueueMapBuffer( + command_queue, + buffer, + blocking_map, + map_flags, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static void* CL_API_CALL clEnqueueMapImage_wrap( + 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 +{ +printf("clEnqueueMapImage\n"); +return tdispatch->clEnqueueMapImage( + command_queue, + image, + blocking_map, + map_flags, + origin, + region, + image_row_pitch, + image_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueUnmapMemObject_wrap( + 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 +{ +printf("clEnqueueUnmapMemObject\n"); +return tdispatch->clEnqueueUnmapMemObject( + command_queue, + memobj, + mapped_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueNDRangeKernel_wrap( + 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 +{ +printf("clEnqueueNDRangeKernel\n"); +return tdispatch->clEnqueueNDRangeKernel( + command_queue, + kernel, + work_dim, + global_work_offset, + global_work_size, + local_work_size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueNativeKernel_wrap( + 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 +{ +printf("clEnqueueNativeKernel\n"); +return tdispatch->clEnqueueNativeKernel( + command_queue, + user_func, + args, + cb_args, + num_mem_objects, + mem_list, + args_mem_loc, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clSetCommandQueueProperty_wrap( + 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 +{ +printf("clSetCommandQueueProperty\n"); +return tdispatch->clSetCommandQueueProperty( + command_queue, + properties, + enable, + old_properties); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateImage2D_wrap( + 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 +{ +printf("clCreateImage2D\n"); +return tdispatch->clCreateImage2D( + context, + flags, + image_format, + image_width, + image_height, + image_row_pitch, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateImage3D_wrap( + 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 +{ +printf("clCreateImage3D\n"); +return tdispatch->clCreateImage3D( + context, + flags, + image_format, + image_width, + image_height, + image_depth, + image_row_pitch, + image_slice_pitch, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueMarker_wrap( + cl_command_queue command_queue, + cl_event* event) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clEnqueueMarker\n"); +return tdispatch->clEnqueueMarker( + command_queue, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clEnqueueWaitForEvents\n"); +return tdispatch->clEnqueueWaitForEvents( + command_queue, + num_events, + event_list); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueBarrier_wrap( + cl_command_queue command_queue) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clEnqueueBarrier\n"); +return tdispatch->clEnqueueBarrier( + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clUnloadCompiler_wrap( + void ) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clUnloadCompiler\n"); +return tdispatch->clUnloadCompiler( + ); +} + +/////////////////////////////////////////////////////////////////////////////// +static void* CL_API_CALL clGetExtensionFunctionAddress_wrap( + const char* func_name) CL_API_SUFFIX__VERSION_1_1_DEPRECATED +{ +printf("clGetExtensionFunctionAddress\n"); +return tdispatch->clGetExtensionFunctionAddress( + func_name); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_command_queue CL_API_CALL clCreateCommandQueue_wrap( + cl_context context, + cl_device_id device, + cl_command_queue_properties properties, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2_DEPRECATED +{ +printf("clCreateCommandQueue\n"); +return tdispatch->clCreateCommandQueue( + context, + device, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_sampler CL_API_CALL clCreateSampler_wrap( + 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_2_DEPRECATED +{ +printf("clCreateSampler\n"); +return tdispatch->clCreateSampler( + context, + normalized_coords, + addressing_mode, + filter_mode, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueTask_wrap( + 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_2_DEPRECATED +{ +printf("clEnqueueTask\n"); +return tdispatch->clEnqueueTask( + command_queue, + kernel, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateSubBuffer_wrap( + 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 +{ +printf("clCreateSubBuffer\n"); +return tdispatch->clCreateSubBuffer( + buffer, + flags, + buffer_create_type, + buffer_create_info, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clSetMemObjectDestructorCallback\n"); +return tdispatch->clSetMemObjectDestructorCallback( + memobj, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_event CL_API_CALL clCreateUserEvent_wrap( + cl_context context, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 +{ +printf("clCreateUserEvent\n"); +return tdispatch->clCreateUserEvent( + context, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clSetUserEventStatus_wrap( + cl_event event, + cl_int execution_status) CL_API_SUFFIX__VERSION_1_1 +{ +printf("clSetUserEventStatus\n"); +return tdispatch->clSetUserEventStatus( + event, + execution_status); +} + +/////////////////////////////////////////////////////////////////////////////// +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), + void* user_data) CL_API_SUFFIX__VERSION_1_1 +{ +printf("clSetEventCallback\n"); +return tdispatch->clSetEventCallback( + event, + command_exec_callback_type, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueReadBufferRect_wrap( + 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 +{ +printf("clEnqueueReadBufferRect\n"); +return tdispatch->clEnqueueReadBufferRect( + command_queue, + buffer, + blocking_read, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueWriteBufferRect_wrap( + 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) CL_API_SUFFIX__VERSION_1_1 +{ +printf("clEnqueueWriteBufferRect\n"); +return tdispatch->clEnqueueWriteBufferRect( + command_queue, + buffer, + blocking_write, + buffer_origin, + host_origin, + region, + buffer_row_pitch, + buffer_slice_pitch, + host_row_pitch, + host_slice_pitch, + ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueCopyBufferRect_wrap( + 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 +{ +printf("clEnqueueCopyBufferRect\n"); +return tdispatch->clEnqueueCopyBufferRect( + command_queue, + src_buffer, + dst_buffer, + src_origin, + dst_origin, + region, + src_row_pitch, + src_slice_pitch, + dst_row_pitch, + dst_slice_pitch, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clCreateSubDevices_wrap( + 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) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clCreateSubDevices\n"); +return tdispatch->clCreateSubDevices( + in_device, + properties, + num_devices, + out_devices, + num_devices_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clRetainDevice_wrap( + cl_device_id device) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clRetainDevice\n"); +return tdispatch->clRetainDevice( + device); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clReleaseDevice_wrap( + cl_device_id device) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clReleaseDevice\n"); +return tdispatch->clReleaseDevice( + device); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateImage_wrap( + 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 +{ +printf("clCreateImage\n"); +return tdispatch->clCreateImage( + context, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_program CL_API_CALL clCreateProgramWithBuiltInKernels_wrap( + 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 +{ +printf("clCreateProgramWithBuiltInKernels\n"); +return tdispatch->clCreateProgramWithBuiltInKernels( + context, + num_devices, + device_list, + kernel_names, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clCompileProgram_wrap( + 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 +{ +printf("clCompileProgram\n"); +return tdispatch->clCompileProgram( + program, + num_devices, + device_list, + options, + num_input_headers, + input_headers, + header_include_names, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_program CL_API_CALL clLinkProgram_wrap( + 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 +{ +printf("clLinkProgram\n"); +return tdispatch->clLinkProgram( + context, + num_devices, + device_list, + options, + num_input_programs, + input_programs, + pfn_notify, + user_data, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clUnloadPlatformCompiler_wrap( + cl_platform_id platform) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clUnloadPlatformCompiler\n"); +return tdispatch->clUnloadPlatformCompiler( + platform); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetKernelArgInfo_wrap( + 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) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clGetKernelArgInfo\n"); +return tdispatch->clGetKernelArgInfo( + kernel, + arg_index, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueFillBuffer_wrap( + 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) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clEnqueueFillBuffer\n"); +return tdispatch->clEnqueueFillBuffer( + command_queue, + buffer, + pattern, + pattern_size, + offset, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueFillImage_wrap( + 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) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clEnqueueFillImage\n"); +return tdispatch->clEnqueueFillImage( + command_queue, + image, + fill_color, + origin, + region, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueMigrateMemObjects_wrap( + 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 +{ +printf("clEnqueueMigrateMemObjects\n"); +return tdispatch->clEnqueueMigrateMemObjects( + command_queue, + num_mem_objects, + mem_objects, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +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, + cl_event* event) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clEnqueueMarkerWithWaitList\n"); +return tdispatch->clEnqueueMarkerWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +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, + cl_event* event) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clEnqueueBarrierWithWaitList\n"); +return tdispatch->clEnqueueBarrierWithWaitList( + command_queue, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static void* CL_API_CALL clGetExtensionFunctionAddressForPlatform_wrap( + cl_platform_id platform, + const char* func_name) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clGetExtensionFunctionAddressForPlatform\n"); +return tdispatch->clGetExtensionFunctionAddressForPlatform( + platform, + func_name); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_command_queue CL_API_CALL clCreateCommandQueueWithProperties_wrap( + cl_context context, + cl_device_id device, + const cl_queue_properties* properties, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_0 +{ +printf("clCreateCommandQueueWithProperties\n"); +return tdispatch->clCreateCommandQueueWithProperties( + context, + device, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreatePipe_wrap( + 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 +{ +printf("clCreatePipe\n"); +return tdispatch->clCreatePipe( + context, + flags, + pipe_packet_size, + pipe_max_packets, + properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetPipeInfo_wrap( + 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 +{ +printf("clGetPipeInfo\n"); +return tdispatch->clGetPipeInfo( + pipe, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static void* CL_API_CALL clSVMAlloc_wrap( + cl_context context, + cl_svm_mem_flags flags, + size_t size, + cl_uint alignment) CL_API_SUFFIX__VERSION_2_0 +{ +printf("clSVMAlloc\n"); +return tdispatch->clSVMAlloc( + context, + flags, + size, + alignment); +} + +/////////////////////////////////////////////////////////////////////////////// +static void CL_API_CALL clSVMFree_wrap( + cl_context context, + void* svm_pointer) CL_API_SUFFIX__VERSION_2_0 +{ +printf("clSVMFree\n"); +tdispatch->clSVMFree( + context, + svm_pointer); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clCreateSamplerWithProperties\n"); +return tdispatch->clCreateSamplerWithProperties( + context, + sampler_properties, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clSetKernelArgSVMPointer\n"); +return tdispatch->clSetKernelArgSVMPointer( + kernel, + arg_index, + arg_value); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clSetKernelExecInfo_wrap( + cl_kernel kernel, + cl_kernel_exec_info param_name, + size_t param_value_size, + const void* param_value) CL_API_SUFFIX__VERSION_2_0 +{ +printf("clSetKernelExecInfo\n"); +return tdispatch->clSetKernelExecInfo( + kernel, + param_name, + param_value_size, + param_value); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMFree_wrap( + 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 +{ +printf("clEnqueueSVMFree\n"); +return tdispatch->clEnqueueSVMFree( + command_queue, + num_svm_pointers, + svm_pointers, + pfn_free_func, + user_data, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMMemcpy_wrap( + 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 +{ +printf("clEnqueueSVMMemcpy\n"); +return tdispatch->clEnqueueSVMMemcpy( + command_queue, + blocking_copy, + dst_ptr, + src_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMMemFill_wrap( + 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 +{ +printf("clEnqueueSVMMemFill\n"); +return tdispatch->clEnqueueSVMMemFill( + command_queue, + svm_ptr, + pattern, + pattern_size, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMMap_wrap( + 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_2_0 +{ +printf("clEnqueueSVMMap\n"); +return tdispatch->clEnqueueSVMMap( + command_queue, + blocking_map, + flags, + svm_ptr, + size, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMUnmap_wrap( + 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 +{ +printf("clEnqueueSVMUnmap\n"); +return tdispatch->clEnqueueSVMUnmap( + command_queue, + svm_ptr, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clSetDefaultDeviceCommandQueue\n"); +return tdispatch->clSetDefaultDeviceCommandQueue( + context, + device, + command_queue); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clGetDeviceAndHostTimer\n"); +return tdispatch->clGetDeviceAndHostTimer( + device, + device_timestamp, + host_timestamp); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetHostTimer_wrap( + cl_device_id device, + cl_ulong* host_timestamp) CL_API_SUFFIX__VERSION_2_1 +{ +printf("clGetHostTimer\n"); +return tdispatch->clGetHostTimer( + device, + host_timestamp); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_program CL_API_CALL clCreateProgramWithIL_wrap( + cl_context context, + const void* il, + size_t length, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1 +{ +printf("clCreateProgramWithIL\n"); +return tdispatch->clCreateProgramWithIL( + context, + il, + length, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_kernel CL_API_CALL clCloneKernel_wrap( + cl_kernel source_kernel, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_2_1 +{ +printf("clCloneKernel\n"); +return tdispatch->clCloneKernel( + source_kernel, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clGetKernelSubGroupInfo_wrap( + 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 +{ +printf("clGetKernelSubGroupInfo\n"); +return tdispatch->clGetKernelSubGroupInfo( + kernel, + device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clEnqueueSVMMigrateMem_wrap( + 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 +{ +printf("clEnqueueSVMMigrateMem\n"); +return tdispatch->clEnqueueSVMMigrateMem( + command_queue, + num_svm_pointers, + svm_pointers, + sizes, + flags, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_int CL_API_CALL clSetProgramSpecializationConstant_wrap( + cl_program program, + cl_uint spec_id, + size_t spec_size, + const void* spec_value) CL_API_SUFFIX__VERSION_2_2 +{ +printf("clSetProgramSpecializationConstant\n"); +return tdispatch->clSetProgramSpecializationConstant( + program, + spec_id, + spec_size, + spec_value); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clSetProgramReleaseCallback\n"); +return tdispatch->clSetProgramReleaseCallback( + program, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +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 +{ +printf("clSetContextDestructorCallback\n"); +return tdispatch->clSetContextDestructorCallback( + context, + pfn_notify, + user_data); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateBufferWithProperties_wrap( + 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 +{ +printf("clCreateBufferWithProperties\n"); +return tdispatch->clCreateBufferWithProperties( + context, + properties, + flags, + size, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// +static cl_mem CL_API_CALL clCreateImageWithProperties_wrap( + 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 +{ +printf("clCreateImageWithProperties\n"); +return tdispatch->clCreateImageWithProperties( + context, + properties, + flags, + image_format, + image_desc, + host_ptr, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// + +// cl_ext_device_fission +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_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_int CL_API_CALL clCreateSubDevicesEXT_wrap( + 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 +{ +printf("clCreateSubDevicesEXT\n"); +return tdispatch->clCreateSubDevicesEXT( + in_device, + properties, + num_entries, + out_devices, + num_devices); +} + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_d3d10_sharing + +#if defined(_WIN32) +static cl_int CL_API_CALL clGetDeviceIDsFromD3D10KHR_wrap( + 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 +{ +printf("clGetDeviceIDsFromD3D10KHR\n"); +return tdispatch->clGetDeviceIDsFromD3D10KHR( + platform, + d3d_device_source, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +static cl_mem CL_API_CALL clCreateFromD3D10BufferKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D10Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateFromD3D10BufferKHR\n"); +return tdispatch->clCreateFromD3D10BufferKHR( + context, + flags, + resource, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromD3D10Texture2DKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D10Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateFromD3D10Texture2DKHR\n"); +return tdispatch->clCreateFromD3D10Texture2DKHR( + context, + flags, + resource, + subresource, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromD3D10Texture3DKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D10Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateFromD3D10Texture3DKHR\n"); +return tdispatch->clCreateFromD3D10Texture3DKHR( + context, + flags, + resource, + subresource, + errcode_ret); +} +static cl_int CL_API_CALL clEnqueueAcquireD3D10ObjectsKHR_wrap( + 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 +{ +printf("clEnqueueAcquireD3D10ObjectsKHR\n"); +return tdispatch->clEnqueueAcquireD3D10ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +static cl_int CL_API_CALL clEnqueueReleaseD3D10ObjectsKHR_wrap( + 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 +{ +printf("clEnqueueReleaseD3D10ObjectsKHR\n"); +return tdispatch->clEnqueueReleaseD3D10ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_d3d11_sharing + +#if defined(_WIN32) +static cl_int CL_API_CALL clGetDeviceIDsFromD3D11KHR_wrap( + 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 +{ +printf("clGetDeviceIDsFromD3D11KHR\n"); +return tdispatch->clGetDeviceIDsFromD3D11KHR( + platform, + d3d_device_source, + d3d_object, + d3d_device_set, + num_entries, + devices, + num_devices); +} +static cl_mem CL_API_CALL clCreateFromD3D11BufferKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D11Buffer* resource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clCreateFromD3D11BufferKHR\n"); +return tdispatch->clCreateFromD3D11BufferKHR( + context, + flags, + resource, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromD3D11Texture2DKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D11Texture2D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clCreateFromD3D11Texture2DKHR\n"); +return tdispatch->clCreateFromD3D11Texture2DKHR( + context, + flags, + resource, + subresource, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromD3D11Texture3DKHR_wrap( + cl_context context, + cl_mem_flags flags, + ID3D11Texture3D* resource, + UINT subresource, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_2 +{ +printf("clCreateFromD3D11Texture3DKHR\n"); +return tdispatch->clCreateFromD3D11Texture3DKHR( + context, + flags, + resource, + subresource, + errcode_ret); +} +static cl_int CL_API_CALL clEnqueueAcquireD3D11ObjectsKHR_wrap( + 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 +{ +printf("clEnqueueAcquireD3D11ObjectsKHR\n"); +return tdispatch->clEnqueueAcquireD3D11ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +static cl_int CL_API_CALL clEnqueueReleaseD3D11ObjectsKHR_wrap( + 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 +{ +printf("clEnqueueReleaseD3D11ObjectsKHR\n"); +return tdispatch->clEnqueueReleaseD3D11ObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_dx9_media_sharing + +#if defined(_WIN32) +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, + 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 +{ +printf("clGetDeviceIDsFromDX9MediaAdapterKHR\n"); +return tdispatch->clGetDeviceIDsFromDX9MediaAdapterKHR( + platform, + num_media_adapters, + media_adapter_type, + media_adapters, + media_adapter_set, + num_entries, + devices, + num_devices); +} +static cl_mem CL_API_CALL clCreateFromDX9MediaSurfaceKHR_wrap( + 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 +{ +printf("clCreateFromDX9MediaSurfaceKHR\n"); +return tdispatch->clCreateFromDX9MediaSurfaceKHR( + context, + flags, + adapter_type, + surface_info, + plane, + errcode_ret); +} +static cl_int CL_API_CALL clEnqueueAcquireDX9MediaSurfacesKHR_wrap( + 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 +{ +printf("clEnqueueAcquireDX9MediaSurfacesKHR\n"); +return tdispatch->clEnqueueAcquireDX9MediaSurfacesKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +static cl_int CL_API_CALL clEnqueueReleaseDX9MediaSurfacesKHR_wrap( + 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 +{ +printf("clEnqueueReleaseDX9MediaSurfacesKHR\n"); +return tdispatch->clEnqueueReleaseDX9MediaSurfacesKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} + +#endif // defined(_WIN32) + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_egl_event +static cl_event CL_API_CALL clCreateEventFromEGLSyncKHR_wrap( + cl_context context, + CLeglSyncKHR sync, + CLeglDisplayKHR display, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateEventFromEGLSyncKHR\n"); +return tdispatch->clCreateEventFromEGLSyncKHR( + context, + sync, + display, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_egl_image +static cl_mem CL_API_CALL clCreateFromEGLImageKHR_wrap( + 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 +{ +printf("clCreateFromEGLImageKHR\n"); +return tdispatch->clCreateFromEGLImageKHR( + context, + egldisplay, + eglimage, + flags, + properties, + errcode_ret); +} +static cl_int CL_API_CALL clEnqueueAcquireEGLObjectsKHR_wrap( + 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 +{ +printf("clEnqueueAcquireEGLObjectsKHR\n"); +return tdispatch->clEnqueueAcquireEGLObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +static cl_int CL_API_CALL clEnqueueReleaseEGLObjectsKHR_wrap( + 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 +{ +printf("clEnqueueReleaseEGLObjectsKHR\n"); +return tdispatch->clEnqueueReleaseEGLObjectsKHR( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_gl_event +static cl_event CL_API_CALL clCreateEventFromGLsyncKHR_wrap( + cl_context context, + cl_GLsync sync, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_1 +{ +printf("clCreateEventFromGLsyncKHR\n"); +return tdispatch->clCreateEventFromGLsyncKHR( + context, + sync, + errcode_ret); +} + +/////////////////////////////////////////////////////////////////////////////// + +// cl_khr_gl_sharing +static cl_int CL_API_CALL clGetGLContextInfoKHR_wrap( + 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 +{ +printf("clGetGLContextInfoKHR\n"); +return tdispatch->clGetGLContextInfoKHR( + properties, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +static cl_mem CL_API_CALL clCreateFromGLBuffer_wrap( + cl_context context, + cl_mem_flags flags, + cl_GLuint bufobj, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateFromGLBuffer\n"); +return tdispatch->clCreateFromGLBuffer( + context, + flags, + bufobj, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromGLTexture_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_2 +{ +printf("clCreateFromGLTexture\n"); +return tdispatch->clCreateFromGLTexture( + context, + flags, + target, + miplevel, + texture, + errcode_ret); +} +static cl_mem CL_API_CALL clCreateFromGLRenderbuffer_wrap( + cl_context context, + cl_mem_flags flags, + cl_GLuint renderbuffer, + cl_int* errcode_ret) CL_API_SUFFIX__VERSION_1_0 +{ +printf("clCreateFromGLRenderbuffer\n"); +return tdispatch->clCreateFromGLRenderbuffer( + context, + flags, + renderbuffer, + errcode_ret); +} +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 +{ +printf("clGetGLObjectInfo\n"); +return tdispatch->clGetGLObjectInfo( + memobj, + gl_object_type, + gl_object_name); +} +static cl_int CL_API_CALL clGetGLTextureInfo_wrap( + 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 +{ +printf("clGetGLTextureInfo\n"); +return tdispatch->clGetGLTextureInfo( + memobj, + param_name, + param_value_size, + param_value, + param_value_size_ret); +} +static cl_int CL_API_CALL clEnqueueAcquireGLObjects_wrap( + 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 +{ +printf("clEnqueueAcquireGLObjects\n"); +return tdispatch->clEnqueueAcquireGLObjects( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + event_wait_list, + event); +} +static cl_int CL_API_CALL clEnqueueReleaseGLObjects_wrap( + 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 +{ +printf("clEnqueueReleaseGLObjects\n"); +return tdispatch->clEnqueueReleaseGLObjects( + command_queue, + num_objects, + mem_objects, + num_events_in_wait_list, + 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_int CL_API_CALL clGetKernelSubGroupInfoKHR_wrap( + 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 +{ +printf("clGetKernelSubGroupInfoKHR\n"); +return tdispatch->clGetKernelSubGroupInfoKHR( + in_kernel, + in_device, + param_name, + input_value_size, + input_value, + param_value_size, + param_value, + param_value_size_ret); +} + +/////////////////////////////////////////////////////////////////////////////// + +void _init_dispatch(void) { + dispatch.clGetPlatformIDs = &clGetPlatformIDs_wrap; + dispatch.clGetPlatformInfo = &clGetPlatformInfo_wrap; + dispatch.clGetDeviceIDs = &clGetDeviceIDs_wrap; + dispatch.clGetDeviceInfo = &clGetDeviceInfo_wrap; + dispatch.clCreateContext = &clCreateContext_wrap; + dispatch.clCreateContextFromType = &clCreateContextFromType_wrap; + dispatch.clRetainContext = &clRetainContext_wrap; + dispatch.clReleaseContext = &clReleaseContext_wrap; + dispatch.clGetContextInfo = &clGetContextInfo_wrap; + dispatch.clCreateCommandQueue = &clCreateCommandQueue_wrap; + dispatch.clRetainCommandQueue = &clRetainCommandQueue_wrap; + dispatch.clReleaseCommandQueue = &clReleaseCommandQueue_wrap; + dispatch.clGetCommandQueueInfo = &clGetCommandQueueInfo_wrap; + dispatch.clSetCommandQueueProperty = &clSetCommandQueueProperty_wrap; + dispatch.clCreateBuffer = &clCreateBuffer_wrap; + dispatch.clCreateImage2D = &clCreateImage2D_wrap; + dispatch.clCreateImage3D = &clCreateImage3D_wrap; + dispatch.clRetainMemObject = &clRetainMemObject_wrap; + dispatch.clReleaseMemObject = &clReleaseMemObject_wrap; + dispatch.clGetSupportedImageFormats = &clGetSupportedImageFormats_wrap; + dispatch.clGetMemObjectInfo = &clGetMemObjectInfo_wrap; + dispatch.clGetImageInfo = &clGetImageInfo_wrap; + dispatch.clCreateSampler = &clCreateSampler_wrap; + dispatch.clRetainSampler = &clRetainSampler_wrap; + dispatch.clReleaseSampler = &clReleaseSampler_wrap; + dispatch.clGetSamplerInfo = &clGetSamplerInfo_wrap; + dispatch.clCreateProgramWithSource = &clCreateProgramWithSource_wrap; + dispatch.clCreateProgramWithBinary = &clCreateProgramWithBinary_wrap; + dispatch.clRetainProgram = &clRetainProgram_wrap; + dispatch.clReleaseProgram = &clReleaseProgram_wrap; + dispatch.clBuildProgram = &clBuildProgram_wrap; + dispatch.clUnloadCompiler = &clUnloadCompiler_wrap; + dispatch.clGetProgramInfo = &clGetProgramInfo_wrap; + dispatch.clGetProgramBuildInfo = &clGetProgramBuildInfo_wrap; + dispatch.clCreateKernel = &clCreateKernel_wrap; + dispatch.clCreateKernelsInProgram = &clCreateKernelsInProgram_wrap; + dispatch.clRetainKernel = &clRetainKernel_wrap; + dispatch.clReleaseKernel = &clReleaseKernel_wrap; + dispatch.clSetKernelArg = &clSetKernelArg_wrap; + dispatch.clGetKernelInfo = &clGetKernelInfo_wrap; + dispatch.clGetKernelWorkGroupInfo = &clGetKernelWorkGroupInfo_wrap; + dispatch.clWaitForEvents = &clWaitForEvents_wrap; + dispatch.clGetEventInfo = &clGetEventInfo_wrap; + dispatch.clRetainEvent = &clRetainEvent_wrap; + dispatch.clReleaseEvent = &clReleaseEvent_wrap; + dispatch.clGetEventProfilingInfo = &clGetEventProfilingInfo_wrap; + dispatch.clFlush = &clFlush_wrap; + dispatch.clFinish = &clFinish_wrap; + dispatch.clEnqueueReadBuffer = &clEnqueueReadBuffer_wrap; + dispatch.clEnqueueWriteBuffer = &clEnqueueWriteBuffer_wrap; + dispatch.clEnqueueCopyBuffer = &clEnqueueCopyBuffer_wrap; + dispatch.clEnqueueReadImage = &clEnqueueReadImage_wrap; + dispatch.clEnqueueWriteImage = &clEnqueueWriteImage_wrap; + dispatch.clEnqueueCopyImage = &clEnqueueCopyImage_wrap; + dispatch.clEnqueueCopyImageToBuffer = &clEnqueueCopyImageToBuffer_wrap; + dispatch.clEnqueueCopyBufferToImage = &clEnqueueCopyBufferToImage_wrap; + dispatch.clEnqueueMapBuffer = &clEnqueueMapBuffer_wrap; + dispatch.clEnqueueMapImage = &clEnqueueMapImage_wrap; + dispatch.clEnqueueUnmapMemObject = &clEnqueueUnmapMemObject_wrap; + dispatch.clEnqueueNDRangeKernel = &clEnqueueNDRangeKernel_wrap; + dispatch.clEnqueueTask = &clEnqueueTask_wrap; + dispatch.clEnqueueNativeKernel = &clEnqueueNativeKernel_wrap; + dispatch.clEnqueueMarker = &clEnqueueMarker_wrap; + dispatch.clEnqueueWaitForEvents = &clEnqueueWaitForEvents_wrap; + dispatch.clEnqueueBarrier = &clEnqueueBarrier_wrap; + dispatch.clGetExtensionFunctionAddress = &clGetExtensionFunctionAddress_wrap; + dispatch.clCreateFromGLBuffer = &clCreateFromGLBuffer_wrap; + dispatch.clCreateFromGLTexture2D = &clCreateFromGLTexture2D_wrap; + dispatch.clCreateFromGLTexture3D = &clCreateFromGLTexture3D_wrap; + dispatch.clCreateFromGLRenderbuffer = &clCreateFromGLRenderbuffer_wrap; + dispatch.clGetGLObjectInfo = &clGetGLObjectInfo_wrap; + dispatch.clGetGLTextureInfo = &clGetGLTextureInfo_wrap; + dispatch.clEnqueueAcquireGLObjects = &clEnqueueAcquireGLObjects_wrap; + dispatch.clEnqueueReleaseGLObjects = &clEnqueueReleaseGLObjects_wrap; + dispatch.clGetGLContextInfoKHR = &clGetGLContextInfoKHR_wrap; + + /* cl_khr_d3d10_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromD3D10KHR = &clGetDeviceIDsFromD3D10KHR_wrap; + dispatch.clCreateFromD3D10BufferKHR = &clCreateFromD3D10BufferKHR_wrap; + dispatch.clCreateFromD3D10Texture2DKHR = &clCreateFromD3D10Texture2DKHR_wrap; + dispatch.clCreateFromD3D10Texture3DKHR = &clCreateFromD3D10Texture3DKHR_wrap; + dispatch.clEnqueueAcquireD3D10ObjectsKHR = &clEnqueueAcquireD3D10ObjectsKHR_wrap; + dispatch.clEnqueueReleaseD3D10ObjectsKHR = &clEnqueueReleaseD3D10ObjectsKHR_wrap; +#else + dispatch.clGetDeviceIDsFromD3D10KHR = NULL; + dispatch.clCreateFromD3D10BufferKHR = NULL; + dispatch.clCreateFromD3D10Texture2DKHR = NULL; + dispatch.clCreateFromD3D10Texture3DKHR = NULL; + dispatch.clEnqueueAcquireD3D10ObjectsKHR = NULL; + dispatch.clEnqueueReleaseD3D10ObjectsKHR = NULL; +#endif + + /* OpenCL 1.1 */ + dispatch.clSetEventCallback = &clSetEventCallback_wrap; + dispatch.clCreateSubBuffer = &clCreateSubBuffer_wrap; + dispatch.clSetMemObjectDestructorCallback = &clSetMemObjectDestructorCallback_wrap; + dispatch.clCreateUserEvent = &clCreateUserEvent_wrap; + dispatch.clSetUserEventStatus = &clSetUserEventStatus_wrap; + dispatch.clEnqueueReadBufferRect = &clEnqueueReadBufferRect_wrap; + dispatch.clEnqueueWriteBufferRect = &clEnqueueWriteBufferRect_wrap; + dispatch.clEnqueueCopyBufferRect = &clEnqueueCopyBufferRect_wrap; + + /* cl_ext_device_fission */ + dispatch.clCreateSubDevicesEXT = &clCreateSubDevicesEXT_wrap; + dispatch.clRetainDeviceEXT = &clRetainDeviceEXT_wrap; + dispatch.clReleaseDeviceEXT = &clReleaseDeviceEXT_wrap; + + /* cl_khr_gl_event */ + dispatch.clCreateEventFromGLsyncKHR = &clCreateEventFromGLsyncKHR_wrap; + + /* OpenCL 1.2 */ + dispatch.clCreateSubDevices = &clCreateSubDevices_wrap; + dispatch.clRetainDevice = &clRetainDevice_wrap; + dispatch.clReleaseDevice = &clReleaseDevice_wrap; + dispatch.clCreateImage = &clCreateImage_wrap; + dispatch.clCreateProgramWithBuiltInKernels = &clCreateProgramWithBuiltInKernels_wrap; + dispatch.clCompileProgram = &clCompileProgram_wrap; + dispatch.clLinkProgram = &clLinkProgram_wrap; + dispatch.clUnloadPlatformCompiler = &clUnloadPlatformCompiler_wrap; + dispatch.clGetKernelArgInfo = &clGetKernelArgInfo_wrap; + dispatch.clEnqueueFillBuffer = &clEnqueueFillBuffer_wrap; + dispatch.clEnqueueFillImage = &clEnqueueFillImage_wrap; + dispatch.clEnqueueMigrateMemObjects = &clEnqueueMigrateMemObjects_wrap; + dispatch.clEnqueueMarkerWithWaitList = &clEnqueueMarkerWithWaitList_wrap; + dispatch.clEnqueueBarrierWithWaitList = &clEnqueueBarrierWithWaitList_wrap; + dispatch.clGetExtensionFunctionAddressForPlatform = &clGetExtensionFunctionAddressForPlatform_wrap; + dispatch.clCreateFromGLTexture = &clCreateFromGLTexture_wrap; + + /* cl_khr_d3d11_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromD3D11KHR = &clGetDeviceIDsFromD3D11KHR_wrap; + dispatch.clCreateFromD3D11BufferKHR = &clCreateFromD3D11BufferKHR_wrap; + dispatch.clCreateFromD3D11Texture2DKHR = &clCreateFromD3D11Texture2DKHR_wrap; + dispatch.clCreateFromD3D11Texture3DKHR = &clCreateFromD3D11Texture3DKHR_wrap; + dispatch.clCreateFromDX9MediaSurfaceKHR = &clCreateFromDX9MediaSurfaceKHR_wrap; + dispatch.clEnqueueAcquireD3D11ObjectsKHR = &clEnqueueAcquireD3D11ObjectsKHR_wrap; + dispatch.clEnqueueReleaseD3D11ObjectsKHR = &clEnqueueReleaseD3D11ObjectsKHR_wrap; +#else + dispatch.clGetDeviceIDsFromD3D11KHR = NULL; + dispatch.clCreateFromD3D11BufferKHR = NULL; + dispatch.clCreateFromD3D11Texture2DKHR = NULL; + dispatch.clCreateFromD3D11Texture3DKHR = NULL; + dispatch.clCreateFromDX9MediaSurfaceKHR = NULL; + dispatch.clEnqueueAcquireD3D11ObjectsKHR = NULL; + dispatch.clEnqueueReleaseD3D11ObjectsKHR = NULL; +#endif + + /* cl_khr_dx9_media_sharing */ +#if defined(_WIN32) + dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = &clGetDeviceIDsFromDX9MediaAdapterKHR_wrap; + dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = &clEnqueueAcquireDX9MediaSurfacesKHR_wrap; + dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = &clEnqueueReleaseDX9MediaSurfacesKHR_wrap; +#else + dispatch.clGetDeviceIDsFromDX9MediaAdapterKHR = NULL; + dispatch.clEnqueueAcquireDX9MediaSurfacesKHR = NULL; + dispatch.clEnqueueReleaseDX9MediaSurfacesKHR = NULL; +#endif + + /* cl_khr_egl_image */ + dispatch.clCreateFromEGLImageKHR = &clCreateFromEGLImageKHR_wrap; + dispatch.clEnqueueAcquireEGLObjectsKHR = &clEnqueueAcquireEGLObjectsKHR_wrap; + dispatch.clEnqueueReleaseEGLObjectsKHR = &clEnqueueReleaseEGLObjectsKHR_wrap; + + /* cl_khr_egl_event */ + dispatch.clCreateEventFromEGLSyncKHR = &clCreateEventFromEGLSyncKHR_wrap; + + /* OpenCL 2.0 */ + dispatch.clCreateCommandQueueWithProperties = &clCreateCommandQueueWithProperties_wrap; + dispatch.clCreatePipe = &clCreatePipe_wrap; + dispatch.clGetPipeInfo = &clGetPipeInfo_wrap; + dispatch.clSVMAlloc = &clSVMAlloc_wrap; + dispatch.clSVMFree = &clSVMFree_wrap; + dispatch.clEnqueueSVMFree = &clEnqueueSVMFree_wrap; + dispatch.clEnqueueSVMMemcpy = &clEnqueueSVMMemcpy_wrap; + dispatch.clEnqueueSVMMemFill = &clEnqueueSVMMemFill_wrap; + dispatch.clEnqueueSVMMap = &clEnqueueSVMMap_wrap; + dispatch.clEnqueueSVMUnmap = &clEnqueueSVMUnmap_wrap; + dispatch.clCreateSamplerWithProperties = &clCreateSamplerWithProperties_wrap; + dispatch.clSetKernelArgSVMPointer = &clSetKernelArgSVMPointer_wrap; + dispatch.clSetKernelExecInfo = &clSetKernelExecInfo_wrap; + + /* cl_khr_sub_groups */ + dispatch.clGetKernelSubGroupInfoKHR = &clGetKernelSubGroupInfoKHR_wrap; + + /* OpenCL 2.1 */ + dispatch.clCloneKernel = &clCloneKernel_wrap; + dispatch.clCreateProgramWithIL = &clCreateProgramWithIL_wrap; + dispatch.clEnqueueSVMMigrateMem = &clEnqueueSVMMigrateMem_wrap; + dispatch.clGetDeviceAndHostTimer = &clGetDeviceAndHostTimer_wrap; + dispatch.clGetHostTimer = &clGetHostTimer_wrap; + dispatch.clGetKernelSubGroupInfo = &clGetKernelSubGroupInfo_wrap; + dispatch.clSetDefaultDeviceCommandQueue = &clSetDefaultDeviceCommandQueue_wrap; + + /* OpenCL 2.2 */ + dispatch.clSetProgramReleaseCallback = &clSetProgramReleaseCallback_wrap; + dispatch.clSetProgramSpecializationConstant = &clSetProgramSpecializationConstant_wrap; + + /* OpenCL 3.0 */ + dispatch.clCreateBufferWithProperties = &clCreateBufferWithProperties_wrap; + dispatch.clCreateImageWithProperties = &clCreateImageWithProperties_wrap; + dispatch.clSetContextDestructorCallback = &clSetContextDestructorCallback_wrap; +} diff --git a/test/loader_test/CMakeLists.txt b/test/loader_test/CMakeLists.txt index ddc675b..3a40121 100644 --- a/test/loader_test/CMakeLists.txt +++ b/test/loader_test/CMakeLists.txt @@ -12,4 +12,9 @@ add_executable (icd_loader_test test_clgl.c test_image_objects.c ) -target_link_libraries (icd_loader_test OpenCL IcdLog) +target_compile_definitions(icd_loader_test + PRIVATE + CL_TARGET_OPENCL_VERSION=300 +) + +target_link_libraries (icd_loader_test OpenCL IcdLog OpenCL::Headers) diff --git a/test/loader_test/callbacks.c b/test/loader_test/callbacks.c index 8e0b493..73d5a95 100644 --- a/test/loader_test/callbacks.c +++ b/test/loader_test/callbacks.c @@ -11,6 +11,11 @@ void CL_CALLBACK createcontext_callback(const char* _a, const void* _b, size_t _ _d); } +void CL_CALLBACK setcontextdestructor_callback(cl_context _a, void* _b) +{ + test_icd_app_log("setcontextdestructor_callback(%p, %p)\n", _a, _b); +} + void CL_CALLBACK setmemobjectdestructor_callback(cl_mem _a, void* _b) { test_icd_app_log("setmemobjectdestructor_callback(%p, %p)\n", diff --git a/test/loader_test/icd_test_match.c b/test/loader_test/icd_test_match.c index a8330b4..b70e741 100644 --- a/test/loader_test/icd_test_match.c +++ b/test/loader_test/icd_test_match.c @@ -1,4 +1,5 @@ #include +#include #include #ifndef __APPLE__ #include @@ -25,7 +26,9 @@ int test_icd_match() } if (strcmp(app_log, stub_log)) { - printf("ERROR: App log and stub log differ.\n"); + printf("ERROR: App log and stub log differ.\n\n"); + printf("APPLOG:\n%s\n\n", app_log); + printf("STUBLOG:\n%s\n\n", stub_log); error = 1; goto End; } @@ -35,4 +38,3 @@ int test_icd_match() free(stub_log); return error; } - diff --git a/test/loader_test/main.c b/test/loader_test/main.c index 1d783d1..b8b7304 100644 --- a/test/loader_test/main.c +++ b/test/loader_test/main.c @@ -18,6 +18,8 @@ extern int test_icd_match(); int main(int argc, char **argv) { + (void)argc; + (void)argv; test_icd_initialize_app_log(); test_icd_initialize_stub_log(); diff --git a/test/loader_test/param_struct.h b/test/loader_test/param_struct.h index 06a1f2b..00d96a9 100644 --- a/test/loader_test/param_struct.h +++ b/test/loader_test/param_struct.h @@ -3,7 +3,6 @@ #include #include -#include struct clCreateCommandQueue_st { @@ -68,6 +67,13 @@ struct clGetContextInfo_st size_t *param_value_size_ret; }; +struct clSetContextDestructorCallback_st +{ + cl_context context; + void (CL_CALLBACK *pfn_notify)(cl_context context, void *user_data); + void *user_data; +}; + struct clGetPlatformIDs_st { cl_uint num_entries; @@ -113,6 +119,7 @@ struct clReleaseCommandQueue_st #define NUM_ITEMS_clRetainContext 1 #define NUM_ITEMS_clReleaseContext 1 #define NUM_ITEMS_clGetContextInfo 1 +#define NUM_ITEMS_clSetContextDestructorCallback 1 #define NUM_ITEMS_clGetPlatformIDs 1 #define NUM_ITEMS_clGetPlatformInfo 1 #define NUM_ITEMS_clGetDeviceIDs 1 @@ -151,6 +158,7 @@ struct clReleaseDevice_st #define NUM_ITEMS_clCreateBuffer 1 +#define NUM_ITEMS_clCreateBufferWithProperties 1 #define NUM_ITEMS_clCreateSubBuffer 1 #define NUM_ITEMS_clEnqueueReadBuffer 1 #define NUM_ITEMS_clEnqueueWriteBuffer 1 @@ -174,6 +182,17 @@ struct clCreateBuffer_st void *host_ptr; cl_int *errcode_ret; }; + +struct clCreateBufferWithProperties_st +{ + cl_context context; + const cl_mem_properties * properties; + cl_mem_flags flags; + size_t size; + void *host_ptr; + cl_int *errcode_ret; +}; + struct clCreateSubBuffer_st { cl_mem buffer; @@ -473,6 +492,7 @@ struct clGetProgramBuildInfo_st #define NUM_ITEMS_clCreateImage2D 1 #define NUM_ITEMS_clCreateImage3D 1 #define NUM_ITEMS_clCreateImage 1 +#define NUM_ITEMS_clCreateImageWithProperties 1 #define NUM_ITEMS_clGetSupportedImageFormats 1 #define NUM_ITEMS_clEnqueueCopyImageToBuffer 1 #define NUM_ITEMS_clEnqueueCopyBufferToImage 1 @@ -494,6 +514,17 @@ struct clCreateImage_st cl_int *errcode_ret; }; +struct clCreateImageWithProperties_st +{ + 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; +}; + struct clCreateImage2D_st { cl_context context; @@ -771,7 +802,8 @@ struct clEnqueueMigrateMemObjects_st struct clEnqueueNDRangeKernel_st { cl_command_queue command_queue; - cl_kernel kernel; cl_uint work_dim; + 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; diff --git a/test/loader_test/test_buffer_object.c b/test/loader_test/test_buffer_object.c index 1710e88..38d5b90 100644 --- a/test/loader_test/test_buffer_object.c +++ b/test/loader_test/test_buffer_object.c @@ -336,6 +336,7 @@ int test_clEnqueueMapBuffer(const struct clEnqueueMapBuffer_st *data) int test_clRetainMemObject(const struct clRetainMemObject_st *data) { + (void)data; test_icd_app_log("clRetainMemObject(%p)\n", buffer); ret_val=clRetainMemObject(buffer); @@ -460,4 +461,3 @@ int test_buffer_object() return 0; } - diff --git a/test/loader_test/test_cl_runtime.c b/test/loader_test/test_cl_runtime.c index 6b08212..380627d 100644 --- a/test/loader_test/test_cl_runtime.c +++ b/test/loader_test/test_cl_runtime.c @@ -4,8 +4,6 @@ extern cl_command_queue command_queue; -cl_int ret_val; - const struct clRetainCommandQueue_st clRetainCommandQueueData[NUM_ITEMS_clRetainCommandQueue] = { {NULL} }; @@ -16,6 +14,9 @@ const struct clGetCommandQueueInfo_st clGetCommandQueueInfoData[NUM_ITEMS_clGetC int test_clRetainCommandQueue(const struct clRetainCommandQueue_st *data) { + (void)data; + cl_int ret_val; + test_icd_app_log("clRetainCommandQueue(%p)\n", command_queue); ret_val = clRetainCommandQueue(command_queue); @@ -28,6 +29,8 @@ int test_clRetainCommandQueue(const struct clRetainCommandQueue_st *data) int test_clGetCommandQueueInfo(const struct clGetCommandQueueInfo_st *data) { + cl_int ret_val; + test_icd_app_log("clGetCommandQueueInfo(%p, %u, %u, %p, %p)\n", command_queue, data->param_name, @@ -40,7 +43,7 @@ int test_clGetCommandQueueInfo(const struct clGetCommandQueueInfo_st *data) data->param_value_size, data->param_value, data->param_value_size_ret); - + test_icd_app_log("Value returned: %d\n", ret_val); return 0; @@ -54,7 +57,7 @@ int test_cl_runtime() for (i=0; i #include -#include #include "param_struct.h" #include @@ -12,8 +11,6 @@ extern cl_mem buffer; extern cl_command_queue command_queue; extern cl_event event; extern cl_context_properties context_properties[3]; -cl_int ret_val; -cl_mem ret_mem; struct clCreateFromGLBuffer_st clCreateFromGLBufferData[NUM_ITEMS_clCreateFromGLBuffer] = { {NULL, 0x0, 0, NULL} @@ -21,20 +18,21 @@ struct clCreateFromGLBuffer_st clCreateFromGLBufferData[NUM_ITEMS_clCreateFromGL int test_clCreateFromGLBuffer(const struct clCreateFromGLBuffer_st* data) { + cl_mem ret_mem; test_icd_app_log("clCreateFromGLBuffer(%p, %x, %u, %p)\n", context, data->flags, - data->bufobj, + data->bufobj, data->errcode_ret); ret_mem = clCreateFromGLBuffer(context, data->flags, - data->bufobj, - data->errcode_ret); + data->bufobj, + data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_mem); - + return 0; } @@ -44,23 +42,25 @@ struct clCreateFromGLTexture_st clCreateFromGLTextureData[NUM_ITEMS_clCreateFrom int test_clCreateFromGLTexture(const struct clCreateFromGLTexture_st* data) { + cl_mem ret_mem; + test_icd_app_log("clCreateFromGLTexture(%p, %x, %d, %d, %u, %p)\n", context, - data->flags, + data->flags, data->texture_target, - data->miplevel, - data->texture, + data->miplevel, + data->texture, data->errcode_ret); ret_mem = clCreateFromGLTexture(context, - data->flags, + data->flags, data->texture_target, - data->miplevel, - data->texture, + data->miplevel, + data->texture, data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_mem); - + return 0; } @@ -70,23 +70,25 @@ struct clCreateFromGLTexture2D_st clCreateFromGLTexture2DData[NUM_ITEMS_clCreate int test_clCreateFromGLTexture2D(const struct clCreateFromGLTexture2D_st* data) { + cl_mem ret_mem; + test_icd_app_log("clCreateFromGLTexture2D(%p, %x, %d, %d, %u, %p)\n", context, - data->flags, + data->flags, data->texture_target, - data->miplevel, - data->texture, + data->miplevel, + data->texture, data->errcode_ret); ret_mem = clCreateFromGLTexture2D(context, - data->flags, + data->flags, data->texture_target, - data->miplevel, - data->texture, + data->miplevel, + data->texture, data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_mem); - + return 0; } @@ -95,21 +97,23 @@ struct clCreateFromGLTexture3D_st clCreateFromGLTexture3DData[NUM_ITEMS_clCreate }; int test_clCreateFromGLTexture3D(const struct clCreateFromGLTexture3D_st* data) -{ +{ + cl_mem ret_mem; + test_icd_app_log("clCreateFromGLTexture3D(%p, %x, %d, %d, %u, %p)\n", context, data->flags, data->texture_target, - data->miplevel, - data->texture, + data->miplevel, + data->texture, data->errcode_ret); ret_mem = clCreateFromGLTexture3D(context, - data->flags, + data->flags, data->texture_target, - data->miplevel, - data->texture, - data->errcode_ret); + data->miplevel, + data->texture, + data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_mem); @@ -122,15 +126,17 @@ struct clCreateFromGLRenderbuffer_st clCreateFromGLRenderbufferData[NUM_ITEMS_cl int test_clCreateFromGLRenderbuffer(const struct clCreateFromGLRenderbuffer_st* data) { + cl_mem ret_mem; + test_icd_app_log("clCreateFromGLRenderbuffer(%p, %x, %d, %p)\n", - context, + context, data->flags, - data->renderbuffer, + data->renderbuffer, data->errcode_ret); - ret_mem = clCreateFromGLRenderbuffer(context, + ret_mem = clCreateFromGLRenderbuffer(context, data->flags, - data->renderbuffer, + data->renderbuffer, data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_mem); @@ -144,17 +150,19 @@ struct clGetGLObjectInfo_st clGetGLObjectInfoData[NUM_ITEMS_clGetGLObjectInfo] = int test_clGetGLObjectInfo(const struct clGetGLObjectInfo_st* data) { + cl_int ret_val; + test_icd_app_log("clGetGLObjectInfo(%p, %p, %p)\n", buffer, - data->gl_object_type, + data->gl_object_type, data->gl_object_name); ret_val = clGetGLObjectInfo(buffer, - data->gl_object_type, + data->gl_object_type, data->gl_object_name); test_icd_app_log("Value returned: %p\n", ret_val); - + return ret_val; } @@ -165,16 +173,18 @@ struct clGetGLTextureInfo_st clGetGLTextureInfoData[NUM_ITEMS_clGetGLTextureInfo int test_clGetGLTextureInfo(const struct clGetGLTextureInfo_st* data) { + cl_int ret_val; + test_icd_app_log("clGetGLTextureInfo(%p, %u, %u, %p, %p)\n", buffer, data->param_name, - data->param_value_size, + data->param_value_size, data->param_value, data->param_value_size_ret); ret_val = clGetGLTextureInfo (buffer, data->param_name, - data->param_value_size, + data->param_value_size, data->param_value, data->param_value_size_ret); @@ -189,19 +199,21 @@ struct clEnqueueAcquireGLObjects_st clEnqueueAcquireGLObjectsData[NUM_ITEMS_clEn int test_clEnqueueAcquireGLObjects(const struct clEnqueueAcquireGLObjects_st* data) { + cl_int ret_val; + test_icd_app_log("clEnqueueAcquireGLObjects(%p, %u, %p, %u, %p, %p)\n", command_queue, - data->num_objects, + data->num_objects, data->mem_objects, data->num_events_in_wait_list, &event, &event); ret_val = clEnqueueAcquireGLObjects (command_queue, - data->num_objects, + data->num_objects, data->mem_objects, data->num_events_in_wait_list, - &event, + &event, &event); test_icd_app_log("Value returned: %p\n", ret_val); @@ -215,19 +227,21 @@ struct clEnqueueReleaseGLObjects_st clEnqueueReleaseGLObjectsData[NUM_ITEMS_clEn int test_clEnqueueReleaseGLObjects(const struct clEnqueueReleaseGLObjects_st* data) { + cl_int ret_val; + test_icd_app_log("clEnqueueReleaseGLObjects(%p, %u, %p, %u, %p, %p)\n", command_queue, - data->num_objects, + data->num_objects, data->mem_objects, data->num_events_in_wait_list, - &event, + &event, &event); ret_val = clEnqueueReleaseGLObjects (command_queue, - data->num_objects, + data->num_objects, data->mem_objects, data->num_events_in_wait_list, - &event, + &event, &event); @@ -240,7 +254,7 @@ struct clCreateEventFromGLsyncKHR_st clCreateEventFromGLsyncKHRData[NUM_ITEMS_cl {NULL, NULL, NULL} }; -typedef CL_API_ENTRY cl_event +typedef cl_event (CL_API_CALL *PFN_clCreateEventFromGLsyncKHR)(cl_context /* context */, cl_GLsync /* cl_GLsync */, cl_int * /* errcode_ret */); @@ -250,18 +264,19 @@ int test_clCreateEventFromGLsyncKHR(const struct clCreateEventFromGLsyncKHR_st* PFN_clCreateEventFromGLsyncKHR pfn_clCreateEventFromGLsyncKHR = NULL; test_icd_app_log("clCreateEventFromGLsyncKHR(%p, %p, %p)\n", - context, - data->sync, + context, + data->sync, data->errcode_ret); - pfn_clCreateEventFromGLsyncKHR = clGetExtensionFunctionAddress("clCreateEventFromGLsyncKHR"); + pfn_clCreateEventFromGLsyncKHR = (PFN_clCreateEventFromGLsyncKHR) + (intptr_t)clGetExtensionFunctionAddress("clCreateEventFromGLsyncKHR"); if (!pfn_clCreateEventFromGLsyncKHR) { test_icd_app_log("clGetExtensionFunctionAddress failed!\n"); return 1; } - ret_event = pfn_clCreateEventFromGLsyncKHR (context, - data->sync, + ret_event = pfn_clCreateEventFromGLsyncKHR (context, + data->sync, data->errcode_ret); test_icd_app_log("Value returned: %p\n", ret_event); @@ -272,24 +287,27 @@ struct clGetGLContextInfoKHR_st clGetGLContextInfoKHRData[NUM_ITEMS_clGetGLConte {NULL, 0, 0, NULL, NULL} }; -typedef CL_API_ENTRY cl_int +typedef cl_int (CL_API_CALL *PFN_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 */); - + int test_clGetGLContextInfoKHR(const struct clGetGLContextInfoKHR_st* data) { + cl_int ret_val; + PFN_clGetGLContextInfoKHR pfn_clGetGLContextInfoKHR = NULL; test_icd_app_log("clGetGLContextInfoKHR(%p, %u, %u, %p, %p)\n", context_properties, data->param_name, - data->param_value_size, + data->param_value_size, data->param_value, data->param_value_size_ret); - pfn_clGetGLContextInfoKHR = clGetExtensionFunctionAddress("clGetGLContextInfoKHR"); + pfn_clGetGLContextInfoKHR = (PFN_clGetGLContextInfoKHR) + (intptr_t)clGetExtensionFunctionAddress("clGetGLContextInfoKHR"); if (!pfn_clGetGLContextInfoKHR) { test_icd_app_log("clGetExtensionFunctionAddress failed!\n"); return 1; @@ -297,7 +315,7 @@ int test_clGetGLContextInfoKHR(const struct clGetGLContextInfoKHR_st* data) ret_val = pfn_clGetGLContextInfoKHR(context_properties, data->param_name, - data->param_value_size, + data->param_value_size, data->param_value, data->param_value_size_ret); @@ -309,7 +327,7 @@ int test_clGetGLContextInfoKHR(const struct clGetGLContextInfoKHR_st* data) int test_OpenGL_share() { int i; - + for(i=0;inum_entries, &platforms, &num_platforms); +#else + (void)data; #endif ret_val = clGetPlatformIDs(0, @@ -180,6 +199,7 @@ int test_clGetPlatformIDs(const struct clGetPlatformIDs_st* data) } } } + free(all_platforms); #if ENABLE_MISMATCHING_PRINTS test_icd_app_log("Value returned: %d\n", ret_val); @@ -299,6 +319,31 @@ int test_clCreateBuffer(const struct clCreateBuffer_st *data) } +int test_clCreateBufferWithProperties(const struct clCreateBufferWithProperties_st *data) +{ + test_icd_app_log("clCreateBufferWithProperties(%p, %p, %x, %u, %p, %p)\n", + context, + data->properties, + data->flags, + data->size, + data->host_ptr, + data->errcode_ret); + + buffer = clCreateBufferWithProperties(context, + data->properties, + data->flags, + data->size, + data->host_ptr, + data->errcode_ret); + + clReleaseMemObjectData->memobj = buffer; + + test_icd_app_log("Value returned: %p\n", buffer); + + return 0; + +} + int test_clCreateSubBuffer(const struct clCreateSubBuffer_st *data) { test_icd_app_log("clCreateSubBuffer(%p, %x, %u, %p, %p)\n", @@ -314,7 +359,7 @@ int test_clCreateSubBuffer(const struct clCreateSubBuffer_st *data) data->buffer_create_info, data->errcode_ret); - clReleaseMemObjectData->memobj = buffer; + clReleaseMemObjectDataSubBuffer->memobj = subBuffer; test_icd_app_log("Value returned: %p\n", subBuffer); @@ -346,6 +391,32 @@ int test_clCreateImage(const struct clCreateImage_st *data) } +int test_clCreateImageWithProperties(const struct clCreateImageWithProperties_st *data) +{ + test_icd_app_log("clCreateImageWithProperties(%p, %p, %x, %p, %p, %p, %p)\n", + context, + data->properties, + data->flags, + data->image_format, + data->image_desc, + data->host_ptr, + data->errcode_ret); + + image = clCreateImageWithProperties(context, + data->properties, + data->flags, + data->image_format, + data->image_desc, + data->host_ptr, + data->errcode_ret); + + clReleaseMemObjectDataImage[0].memobj = image; + test_icd_app_log("Value returned: %p\n", image); + + return 0; + +} + int test_clCreateImage2D(const struct clCreateImage2D_st *data) { test_icd_app_log("clCreateImage2D(%p, %x, %p, %u, %u, %u, %p, %p)\n", @@ -553,6 +624,7 @@ const struct clReleaseSampler_st clReleaseSamplerData[NUM_ITEMS_clReleaseSampler int test_clReleaseSampler(const struct clReleaseSampler_st *data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseSampler(%p)\n", sampler); @@ -585,6 +657,7 @@ const struct clReleaseEvent_st clReleaseEventData[NUM_ITEMS_clReleaseEvent] = int test_clReleaseEvent(const struct clReleaseEvent_st* data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseEvent(%p)\n", event); @@ -604,6 +677,7 @@ const struct clReleaseKernel_st clReleaseKernelData[NUM_ITEMS_clReleaseKernel] = int test_clReleaseKernel(const struct clReleaseKernel_st* data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseKernel(%p)\n", kernel); @@ -623,6 +697,7 @@ const struct clReleaseProgram_st clReleaseProgramData[NUM_ITEMS_clReleaseProgram int test_clReleaseProgram(const struct clReleaseProgram_st *data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseProgram(%p)\n", program); @@ -642,6 +717,7 @@ const struct clReleaseCommandQueue_st clReleaseCommandQueueData[NUM_ITEMS_clRele int test_clReleaseCommandQueue(const struct clReleaseCommandQueue_st *data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseCommandQueue(%p)\n", command_queue); @@ -661,6 +737,7 @@ const struct clReleaseContext_st clReleaseContextData[NUM_ITEMS_clReleaseContext int test_clReleaseContext(const struct clReleaseContext_st* data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseContext(%p)\n", context); @@ -680,6 +757,7 @@ const struct clReleaseDevice_st clReleaseDeviceData[NUM_ITEMS_clReleaseDevice] = int test_clReleaseDevice(const struct clReleaseDevice_st* data) { + (void)data; int ret_val = CL_OUT_OF_RESOURCES; test_icd_app_log("clReleaseDevice(%p)\n", devices); @@ -710,12 +788,20 @@ 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); + test_clCreateImage2D(clCreateImage2DData); test_clReleaseMemObject(clReleaseMemObjectDataImage); @@ -750,6 +836,8 @@ int test_release_calls() test_clReleaseMemObject(clReleaseMemObjectData); + test_clReleaseMemObject(clReleaseMemObjectDataSubBuffer); + test_clReleaseMemObject(clReleaseMemObjectDataImage); test_clReleaseEvent(clReleaseEventData); diff --git a/test/loader_test/test_image_objects.c b/test/loader_test/test_image_objects.c index f399451..c6b99e7 100644 --- a/test/loader_test/test_image_objects.c +++ b/test/loader_test/test_image_objects.c @@ -10,8 +10,6 @@ extern cl_command_queue command_queue; extern cl_event event; extern cl_mem buffer; -int ret_val; - const struct clGetSupportedImageFormats_st clGetSupportedImageFormatsData[NUM_ITEMS_clGetSupportedImageFormats] = { { NULL, 0x0, 0, 0, NULL, NULL } @@ -29,7 +27,7 @@ const struct clEnqueueCopyBufferToImage_st clEnqueueCopyBufferToImageData[NUM_IT const struct clEnqueueMapImage_st clEnqueueMapImageData[NUM_ITEMS_clEnqueueMapImage] = { - { NULL, NULL, 0, 0x0, NULL, NULL, NULL, NULL,0, NULL, NULL} + { NULL, NULL, 0, 0x0, NULL, NULL, NULL, NULL, 0, NULL, NULL, NULL} }; const struct clEnqueueReadImage_st clEnqueueReadImageData[NUM_ITEMS_clEnqueueReadImage] = @@ -59,6 +57,8 @@ const struct clGetImageInfo_st clGetImageInfoData[NUM_ITEMS_clGetImageInfo] = int test_clGetSupportedImageFormats(const struct clGetSupportedImageFormats_st *data) { + cl_int ret_val; + test_icd_app_log("clGetSupportedImageFormats(%p, %x, %u, %u, %p, %p)\n", context, data->flags, @@ -66,7 +66,7 @@ int test_clGetSupportedImageFormats(const struct clGetSupportedImageFormats_st * data->num_entries, data->image_formats, data->num_image_formats); - + ret_val = clGetSupportedImageFormats(context, data->flags, data->image_type, @@ -82,6 +82,8 @@ int test_clGetSupportedImageFormats(const struct clGetSupportedImageFormats_st * int test_clEnqueueCopyImageToBuffer(const struct clEnqueueCopyImageToBuffer_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueCopyImageToBuffer(%p, %p, %p, %p, %p, %u, %u, %p, %p)\n", command_queue, image, @@ -111,6 +113,8 @@ int test_clEnqueueCopyImageToBuffer(const struct clEnqueueCopyImageToBuffer_st * int test_clEnqueueCopyBufferToImage(const struct clEnqueueCopyBufferToImage_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueCopyBufferToImage(%p, %p, %p, %u, %p, %p, %u, %p, %p)\n", command_queue, buffer, @@ -178,11 +182,13 @@ int test_clEnqueueMapImage(const struct clEnqueueMapImage_st *data) int test_clEnqueueReadImage(const struct clEnqueueReadImage_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueReadImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n", command_queue, image, data->blocking_read, - data->origin, + data->origin, data->region, data->row_pitch, data->slice_pitch, @@ -195,11 +201,11 @@ int test_clEnqueueReadImage(const struct clEnqueueReadImage_st *data) image, data->blocking_read, data->origin, - data->region, - data->row_pitch, - data->slice_pitch, - data->ptr, - data->num_events_in_wait_list, + data->region, + data->row_pitch, + data->slice_pitch, + data->ptr, + data->num_events_in_wait_list, data->event_wait_list, &event); @@ -211,6 +217,8 @@ int test_clEnqueueReadImage(const struct clEnqueueReadImage_st *data) int test_clEnqueueWriteImage(const struct clEnqueueWriteImage_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueWriteImage(%p, %p, %u, %p, %p, %u, %u, %p, %u, %p, %p)\n", command_queue, image, @@ -244,6 +252,8 @@ int test_clEnqueueWriteImage(const struct clEnqueueWriteImage_st *data) int test_clEnqueueFillImage(const struct clEnqueueFillImage_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueFillImage(%p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, image, @@ -251,16 +261,16 @@ int test_clEnqueueFillImage(const struct clEnqueueFillImage_st *data) data->origin, data->region, data->num_events_in_wait_list, - data->event_wait_list, + data->event_wait_list, &event); ret_val = clEnqueueFillImage(command_queue, - image, + image, data->fill_color, data->origin, data->region, data->num_events_in_wait_list, - data->event_wait_list, + data->event_wait_list, &event); test_icd_app_log("Value returned: %d\n", ret_val); @@ -270,6 +280,8 @@ int test_clEnqueueFillImage(const struct clEnqueueFillImage_st *data) } int test_clEnqueueCopyImage(const struct clEnqueueCopyImage_st *data) { + cl_int ret_val; + test_icd_app_log("clEnqueueCopyImage(%p, %p, %p, %p, %p, %p, %u, %p, %p)\n", command_queue, image, @@ -278,7 +290,7 @@ int test_clEnqueueCopyImage(const struct clEnqueueCopyImage_st *data) data->dst_origin, data->region, data->num_events_in_wait_list, - data->event_wait_list, + data->event_wait_list, &event); ret_val = clEnqueueCopyImage(command_queue, @@ -288,7 +300,7 @@ int test_clEnqueueCopyImage(const struct clEnqueueCopyImage_st *data) data->dst_origin, data->region, data->num_events_in_wait_list, - data->event_wait_list, + data->event_wait_list, &event); test_icd_app_log("Value returned: %d\n", ret_val); @@ -300,6 +312,8 @@ int test_clEnqueueCopyImage(const struct clEnqueueCopyImage_st *data) int test_clGetImageInfo(const struct clGetImageInfo_st *data) { + cl_int ret_val; + test_icd_app_log("clGetImageInfo(%p, %u, %u, %p, %p)\n", image, data->param_name, diff --git a/test/loader_test/test_kernel.c b/test/loader_test/test_kernel.c index a53e980..2382eab 100644 --- a/test/loader_test/test_kernel.c +++ b/test/loader_test/test_kernel.c @@ -15,7 +15,7 @@ extern cl_event event; extern cl_context context; extern cl_command_queue command_queue; extern cl_device_id devices; -int ret_val; +static int ret_val; extern void CL_CALLBACK setevent_callback(cl_event _a, cl_int _b, void* _c); extern void CL_CALLBACK setprintf_callback(cl_context _a, cl_uint _b, char* _c, void* _d ); @@ -26,6 +26,7 @@ struct clRetainKernel_st clRetainKernelData[NUM_ITEMS_clRetainKernel] = int test_clRetainKernel(const struct clRetainKernel_st* data) { + (void)data; test_icd_app_log("clRetainKernel(%p)\n", kernel); ret_val=clRetainKernel(kernel); @@ -168,7 +169,7 @@ int test_clEnqueueMigrateMemObjects(const struct clEnqueueMigrateMemObjects_st* struct clEnqueueNDRangeKernel_st clEnqueueNDRangeKernelData[NUM_ITEMS_clEnqueueNDRangeKernel] = { - {NULL, NULL, 0, NULL, NULL, NULL, 0, NULL} + {NULL, NULL, 0, NULL, NULL, NULL, 0, NULL, NULL} }; int test_clEnqueueNDRangeKernel(const struct clEnqueueNDRangeKernel_st* data) @@ -345,6 +346,7 @@ struct clRetainEvent_st clRetainEventData[NUM_ITEMS_clRetainEvent] = int test_clRetainEvent(const struct clRetainEvent_st* data) { + (void)data; test_icd_app_log("clRetainEvent(%p)\n", event); ret_val=clRetainEvent(event); @@ -361,6 +363,7 @@ struct clEnqueueMarker_st clEnqueueMarkerData[NUM_ITEMS_clEnqueueMarker] = int test_clEnqueueMarker(const struct clEnqueueMarker_st* data) { + (void)data; test_icd_app_log("clEnqueueMarker(%p, %p)\n", command_queue, &event); ret_val = clEnqueueMarker(command_queue, &event); @@ -443,6 +446,7 @@ struct clEnqueueBarrier_st clEnqueueBarrierData[NUM_ITEMS_clEnqueueBarrier] = int test_clEnqueueBarrier(const struct clEnqueueBarrier_st* data) { + (void)data; test_icd_app_log("clEnqueueBarrier(%p)\n", command_queue); ret_val = clEnqueueBarrier(command_queue); @@ -483,6 +487,7 @@ struct clFlush_st clFlushData[NUM_ITEMS_clFlush] = int test_clFlush(const struct clFlush_st* data) { + (void)data; test_icd_app_log("clFlush(%p)\n", command_queue); ret_val=clFlush(command_queue); @@ -499,6 +504,7 @@ struct clFinish_st clFinishData[NUM_ITEMS_clFinish] = int test_clFinish(const struct clFinish_st* data) { + (void)data; test_icd_app_log("clFinish(%p)\n", command_queue); ret_val=clFinish(command_queue); diff --git a/test/loader_test/test_platforms.c b/test/loader_test/test_platforms.c index d22a3d0..5700738 100644 --- a/test/loader_test/test_platforms.c +++ b/test/loader_test/test_platforms.c @@ -8,7 +8,7 @@ extern cl_platform_id platform; extern cl_device_id devices; -int ret_val; +extern void CL_CALLBACK setcontextdestructor_callback(cl_context _a, void* _b); struct clRetainContext_st clRetainContextData[NUM_ITEMS_clRetainContext] = { @@ -20,6 +20,10 @@ struct clGetContextInfo_st clGetContextInfoData[NUM_ITEMS_clGetContextInfo] = {NULL, 0, 0, NULL, NULL} }; +struct clSetContextDestructorCallback_st clSetContextDestructorCallbackData[NUM_ITEMS_clSetContextDestructorCallback] = +{ + {NULL, setcontextdestructor_callback, NULL} +}; struct clGetPlatformInfo_st clGetPlatformInfoData[NUM_ITEMS_clGetPlatformInfo] = { @@ -45,7 +49,10 @@ struct clRetainDevice_st clRetainDeviceData[NUM_ITEMS_clRetainDevice] = int test_clRetainContext(const struct clRetainContext_st* data) { - test_icd_app_log("clRetainContext(%p)\n", context); + (void)data; + cl_int ret_val; + + test_icd_app_log("clRetainContext(%p)\n", context); ret_val = clRetainContext(context); @@ -55,21 +62,22 @@ int test_clRetainContext(const struct clRetainContext_st* data) } - int test_clGetContextInfo(const struct clGetContextInfo_st* data) { + cl_int ret_val; + test_icd_app_log("clGetContextInfo(%p, %u, %u, %p, %p)\n", context, - data->param_name, + data->param_name, data->param_value_size, - data->param_value, - data->param_value_size_ret); + data->param_value, + data->param_value_size_ret); ret_val = clGetContextInfo(context, - data->param_name, + data->param_name, data->param_value_size, - data->param_value, + data->param_value, data->param_value_size_ret); test_icd_app_log("Value returned: %d\n", ret_val); @@ -77,20 +85,45 @@ int test_clGetContextInfo(const struct clGetContextInfo_st* data) return 0; } + +int test_clSetContextDestructorCallback( + const struct clSetContextDestructorCallback_st* data) +{ + cl_int ret_val; + + test_icd_app_log( + "clSetContextDestructorCallback(%p, %p, %p)\n", + context, + data->pfn_notify, + data->user_data); + + ret_val = clSetContextDestructorCallback( + context, + data->pfn_notify, + data->user_data); + + test_icd_app_log("Value returned: %d\n", ret_val); + + return 0; +} + + int test_clGetPlatformInfo(const struct clGetPlatformInfo_st* data) { + cl_int ret_val; + test_icd_app_log("clGetPlatformInfo(%p, %u, %u, %p, %p)\n", platform, data->param_name, data->param_value_size, - data->param_value, - data->param_value_size_ret); + data->param_value, + data->param_value_size_ret); ret_val = clGetPlatformInfo(platform, data->param_name, data->param_value_size, data->param_value, - data->param_value_size_ret); + data->param_value_size_ret); test_icd_app_log("Value returned: %d\n", ret_val); @@ -99,19 +132,21 @@ int test_clGetPlatformInfo(const struct clGetPlatformInfo_st* data) } int test_clGetDeviceInfo(const struct clGetDeviceInfo_st* data) -{ +{ + cl_int ret_val; + test_icd_app_log("clGetDeviceInfo(%p, %u, %u, %p, %p)\n", devices, - data->param_name, - data->param_value_size, - data->param_value, - data->param_value_size_ret); + data->param_name, + data->param_value_size, + data->param_value, + data->param_value_size_ret); ret_val = clGetDeviceInfo(devices, - data->param_name, - data->param_value_size, - data->param_value, - data->param_value_size_ret); + data->param_name, + data->param_value_size, + data->param_value, + data->param_value_size_ret); test_icd_app_log("Value returned: %d\n", ret_val); @@ -120,18 +155,20 @@ int test_clGetDeviceInfo(const struct clGetDeviceInfo_st* data) int test_clCreateSubDevices(const struct clCreateSubDevices_st* data) { + cl_int ret_val; + test_icd_app_log("clCreateSubDevices(%p, %p, %u, %p, %p)\n", devices, - data->properties, - data->num_entries, - &devices, - data->num_devices); + data->properties, + data->num_entries, + &devices, + data->num_devices); ret_val = clCreateSubDevices(devices, - data->properties, + data->properties, data->num_entries, - &devices, - data->num_devices); + &devices, + data->num_devices); test_icd_app_log("Value returned: %d\n", ret_val); @@ -140,9 +177,12 @@ int test_clCreateSubDevices(const struct clCreateSubDevices_st* data) int test_clRetainDevice(const struct clRetainDevice_st* data) { - test_icd_app_log("clRetainDevice(%p)\n", devices); + (void)data; + cl_int ret_val; + + test_icd_app_log("clRetainDevice(%p)\n", devices); - ret_val = clRetainDevice(devices); + ret_val = clRetainDevice(devices); test_icd_app_log("Value returned: %d\n", ret_val); @@ -153,31 +193,35 @@ int test_platforms() { int i; - for (i = 0;inum_devices, @@ -90,6 +93,8 @@ int test_clBuildProgram(const struct clBuildProgram_st *data) int test_clCompileProgram(const struct clCompileProgram_st *data) { + cl_int ret_val; + test_icd_app_log("clCompileProgram(%p, %u, %p, %p, %u, %p, %p, %p)\n", program, data->num_devices, @@ -119,6 +124,7 @@ int test_clCompileProgram(const struct clCompileProgram_st *data) int test_clLinkProgram(const struct clLinkProgram_st *data) { cl_program program; + cl_int ret_val; test_icd_app_log("clLinkProgram(%p, %u, %p, %p, %u, %p, %p, %p, %p)\n", context, data->num_devices, @@ -142,12 +148,19 @@ int test_clLinkProgram(const struct clLinkProgram_st *data) test_icd_app_log("Value returned: %p\n", program); + test_icd_app_log("clReleaseProgram(%p)\n", program); + ret_val = clReleaseProgram(program); + test_icd_app_log("Value returned: %d\n", ret_val); + return 0; } int test_clUnloadPlatformCompiler(const struct clUnloadPlatformCompiler_st *data) { + (void)data; + cl_int ret_val; + test_icd_app_log("clUnloadPlatformCompiler(%p)\n", platform); ret_val=clUnloadPlatformCompiler(platform); @@ -162,7 +175,7 @@ int test_clGetExtensionFunctionAddressForPlatform(const struct clGetExtensionFun { void *return_value; test_icd_app_log("clGetExtensionFunctionAddressForPlatform(%p, %p)\n", - platform, + platform, data->func_name); return_value=clGetExtensionFunctionAddressForPlatform(platform, @@ -176,6 +189,8 @@ int test_clGetExtensionFunctionAddressForPlatform(const struct clGetExtensionFun int test_clGetProgramInfo(const struct clGetProgramInfo_st *data) { + cl_int ret_val; + test_icd_app_log("clGetProgramInfo(%p, %u, %u, %p, %p)\n", program, data->param_name, @@ -197,6 +212,8 @@ int test_clGetProgramInfo(const struct clGetProgramInfo_st *data) int test_clGetProgramBuildInfo(const struct clGetProgramBuildInfo_st *data) { + cl_int ret_val; + test_icd_app_log("clGetProgramBuildInfo(%p, %p, %u, %u, %p, %p)\n", program, data->device, @@ -224,7 +241,7 @@ int test_program_objects() for (i=0;i extern cl_sampler sampler; -int ret_val; const struct clRetainSampler_st clRetainSamplerData[NUM_ITEMS_clRetainSampler]= { @@ -18,6 +17,9 @@ const struct clGetSamplerInfo_st clGetSamplerInfoData[NUM_ITEMS_clGetSamplerInfo int test_clRetainSampler(const struct clRetainSampler_st *data) { + (void)data; + cl_int ret_val; + test_icd_app_log("clRetainSampler(%p)\n", sampler); ret_val=clRetainSampler(sampler); @@ -29,6 +31,8 @@ int test_clRetainSampler(const struct clRetainSampler_st *data) int test_clGetSamplerInfo(const struct clGetSamplerInfo_st *data) { + cl_int ret_val; + test_icd_app_log("clGetSamplerInfo(%p, %u, %u, %p, %p)\n", sampler, data->param_name, diff --git a/test/log/CMakeLists.txt b/test/log/CMakeLists.txt index 93dea6c..341d19e 100644 --- a/test/log/CMakeLists.txt +++ b/test/log/CMakeLists.txt @@ -1,4 +1,8 @@ -add_library (IcdLog icd_test_log.c) + +add_library (IcdLog SHARED icd_test_log.c) + +target_link_libraries (IcdLog OpenCL::Headers) +target_compile_definitions (IcdLog PRIVATE CL_TARGET_OPENCL_VERSION=300) if (WIN32) target_compile_definitions (IcdLog PRIVATE _CRT_SECURE_NO_WARNINGS) endif() diff --git a/test/pkgconfig/bare/CMakeLists.txt b/test/pkgconfig/bare/CMakeLists.txt new file mode 100644 index 0000000..5e4c099 --- /dev/null +++ b/test/pkgconfig/bare/CMakeLists.txt @@ -0,0 +1,41 @@ +cmake_minimum_required(VERSION 3.0) + +project(PkgConfigTest + LANGUAGES C +) + +find_package(OpenCLHeaders + REQUIRED + CONFIG +) +find_package(OpenCLICDLoader + REQUIRED + CONFIG +) + +add_executable(${PROJECT_NAME} + ../pkgconfig.c +) + +target_link_libraries(${PROJECT_NAME} + PRIVATE + OpenCL::Headers + OpenCL::OpenCL +) + +target_compile_definitions(${PROJECT_NAME} + PRIVATE + CL_TARGET_OPENCL_VERSION=120 +) + +include(CTest) + +add_test( + NAME ${PROJECT_NAME} + COMMAND ${PROJECT_NAME} +) + +set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" +) diff --git a/test/pkgconfig/pkgconfig.c b/test/pkgconfig/pkgconfig.c new file mode 100644 index 0000000..7228099 --- /dev/null +++ b/test/pkgconfig/pkgconfig.c @@ -0,0 +1,56 @@ +#ifdef __APPLE__ //Mac OSX has a different name for the header file +#include +#else +#include +#endif + +#include // printf +#include // malloc +#include // UINTMAX_MAX + +void checkErr(cl_int err, const char * name) +{ + if (err != CL_SUCCESS) + { + printf("ERROR: %s (%i)\n", name, err); + exit( err ); + } +} + +int main() +{ + cl_int CL_err = CL_SUCCESS; + cl_uint numPlatforms = 0; + + CL_err = clGetPlatformIDs(0, NULL, &numPlatforms); + checkErr(CL_err, "clGetPlatformIDs(numPlatforms)"); + + if (numPlatforms == 0) + { + printf("No OpenCL platform detected.\n"); + exit( -1 ); + } + printf("Found %u platform(s)\n\n", numPlatforms); + fflush(NULL); + + cl_platform_id* platforms = (cl_platform_id*)malloc(numPlatforms * sizeof(cl_platform_id)); + CL_err = clGetPlatformIDs(numPlatforms, platforms, NULL); + checkErr(CL_err, "clGetPlatformIDs(platforms)"); + + for (cl_uint i = 0; i < numPlatforms; ++i) + { + size_t vendor_length; + CL_err = clGetPlatformInfo(platforms[i], CL_PLATFORM_VENDOR, 0, NULL, &vendor_length); + checkErr(CL_err, "clGetPlatformInfo(CL_PLATFORM_VENDOR, NULL, &vendor_length)"); + + char* platform_name = (char*)malloc(vendor_length * sizeof(char)); + CL_err = clGetPlatformInfo(platforms[i], CL_PLATFORM_VENDOR, vendor_length, platform_name, NULL); + checkErr(CL_err, "clGetPlatformInfo(CL_PLATFORM_VENDOR, vendor_length, platform_name)"); + + printf("%s\n", platform_name); + fflush(NULL); + free(platform_name); + } + + return 0; +} diff --git a/test/pkgconfig/pkgconfig/CMakeLists.txt b/test/pkgconfig/pkgconfig/CMakeLists.txt new file mode 100644 index 0000000..cffce75 --- /dev/null +++ b/test/pkgconfig/pkgconfig/CMakeLists.txt @@ -0,0 +1,55 @@ +cmake_minimum_required(VERSION 3.1) +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} +) + +set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" +) diff --git a/test/pkgconfig/sdk/CMakeLists.txt b/test/pkgconfig/sdk/CMakeLists.txt new file mode 100644 index 0000000..fced859 --- /dev/null +++ b/test/pkgconfig/sdk/CMakeLists.txt @@ -0,0 +1,40 @@ +cmake_minimum_required(VERSION 3.0) + +project(PkgConfigTest + LANGUAGES C +) + +find_package(OpenCL + REQUIRED + CONFIG + COMPONENTS + Headers + OpenCL +) + +add_executable(${PROJECT_NAME} + ../pkgconfig.c +) + +target_link_libraries(${PROJECT_NAME} + PRIVATE + OpenCL::Headers + OpenCL::OpenCL +) + +target_compile_definitions(${PROJECT_NAME} + PRIVATE + CL_TARGET_OPENCL_VERSION=120 +) + +include(CTest) + +add_test( + NAME ${PROJECT_NAME} + COMMAND ${PROJECT_NAME} +) + +set_tests_properties(${PROJECT_NAME} + PROPERTIES + ENVIRONMENT "OCL_ICD_FILENAMES=${DRIVER_STUB_PATH}" +)