From 9263dd5481ce606107ac2efa0d293e550858335a Mon Sep 17 00:00:00 2001 From: dengliqiang Date: Thu, 12 Sep 2019 18:26:31 +0800 Subject: [PATCH 01/13] Load intel opencl driver by default and fix compiling issue in Android 1, in Android, only one OpenCL driver is loaded, then it is unnecessary to load driver from icd file 2, fix compiling issue in Android to not include file "icd_cmake_config.h" Signed-off-by: dengliqiang --- loader/linux/icd_linux.c | 3 +++ loader/linux/icd_linux_envvars.c | 2 ++ 2 files changed, 5 insertions(+) diff --git a/loader/linux/icd_linux.c b/loader/linux/icd_linux.c index f6ae790..c7acc42 100644 --- a/loader/linux/icd_linux.c +++ b/loader/linux/icd_linux.c @@ -38,6 +38,7 @@ static pthread_once_t initialized = PTHREAD_ONCE_INIT; // go through the list of vendors in the two configuration files void khrIcdOsVendorsEnumerate(void) { +#ifndef __ANDROID__ DIR *dir = NULL; struct dirent *dirEntry = NULL; char* vendorPath = ICD_VENDOR_PATH; @@ -141,6 +142,8 @@ void khrIcdOsVendorsEnumerate(void) { khrIcd_free_getenv(envPath); } +#endif + khrIcdVendorAdd("/vendor/lib64/libigdrcl.so"); } // go through the list of vendors only once diff --git a/loader/linux/icd_linux_envvars.c b/loader/linux/icd_linux_envvars.c index 4af5a08..b71432e 100644 --- a/loader/linux/icd_linux_envvars.c +++ b/loader/linux/icd_linux_envvars.c @@ -21,7 +21,9 @@ #define _GNU_SOURCE #endif +#ifndef __ANDROID__ #include "icd_cmake_config.h" +#endif #include From df3a17e23e0ab09ee09a5a440b9e72e27a3af687 Mon Sep 17 00:00:00 2001 From: dengliqiang Date: Thu, 12 Sep 2019 20:23:39 +0800 Subject: [PATCH 02/13] Add the templates and script for generating bp files Signed-off-by: dengliqiang --- bp/defaults.tpl | 55 +++++ bp/icd-loader.tpl | 82 ++++++++ scripts/androidbpgenerator.py | 313 +++++++++++++++++++++++++++++ scripts/cleanicdloadergenerator.py | 49 +++++ scripts/icdloadergenerator.py | 77 +++++++ 5 files changed, 576 insertions(+) create mode 100755 bp/defaults.tpl create mode 100755 bp/icd-loader.tpl create mode 100755 scripts/androidbpgenerator.py create mode 100755 scripts/cleanicdloadergenerator.py create mode 100755 scripts/icdloadergenerator.py diff --git a/bp/defaults.tpl b/bp/defaults.tpl new file mode 100755 index 0000000..9730967 --- /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_available: true, + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + clang_cflags: [ +@clang_cflags + ], + + include_dirs: [ +@include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} + + +build = [ +@build +] \ No newline at end of file diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl new file mode 100755 index 0000000..6b537e1 --- /dev/null +++ b/bp/icd-loader.tpl @@ -0,0 +1,82 @@ +# 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. +# +# The file-tree of OpenCL-ICD-Loader +# OpenCL-ICD-Loader (cmake -DCMAKE_BUILD_TYPE=Release OpenCL-ICD-Loader) +# | +# +---- libOpenCL.so.1.2 -> Tools/Android/build/icd-loader/CMakeFiles/OpenCL.dir +# | +# +---- test +# | +# +---- log +# | | +# | +---- libIcdLog.so -> Tools/Android/build/icd-loader/test/platform/CMakeFiles/IcdLog.dir +# | +# +---- loader_test +# | | +# | +---- icd_loader_test -> Tools/Android/build/icd-loader/test/loader_test/CMakeFiles/icd_loader_test.dir +# | | +# | => libOpenCL.so.1.2, libIcdLog.so +# | +# +---- driver_stub +# | +# +---- libOpenCLDriverStub.so -> Tools/Android/build/icd-loader/test/driver_stub/CMakeFiles/OpenCLDriverStub.dir +# | +# => libIcdLog.so +# +# About the detailed of soong-build-tools(cc package), please refer to: +# https://ci.android.com/builds/submitted/5357401/linux/latest/view/soong_build.html +# +# +# library_static, library_shared, binary +cc_@module { + name: "@name", + + vendor_available: true, + + defaults: [ +@defaults + ], + + srcs: [ +@srcs + ], + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + local_include_dirs: [ +@local_include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} \ No newline at end of file diff --git a/scripts/androidbpgenerator.py b/scripts/androidbpgenerator.py new file mode 100755 index 0000000..2ff92b8 --- /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 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 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 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 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 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 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..d6523a7 --- /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 middle & build files + print("It is removing build and middle-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/icdloadergenerator.py b/scripts/icdloadergenerator.py new file mode 100755 index 0000000..dc00a04 --- /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/igc/include/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 From de95af5f3900281779b19e9c87f06b79292dccaa Mon Sep 17 00:00:00 2001 From: dengliqiang Date: Thu, 12 Sep 2019 20:25:43 +0800 Subject: [PATCH 03/13] Add all of bp files which are generated by script and templates for compiling. Signed-off-by: dengliqiang --- Android.bp | 40 ++++++++++++++++++++++++++++++++++ icd_loader_test.bp | 49 ++++++++++++++++++++++++++++++++++++++++++ libIcdLog.bp | 39 +++++++++++++++++++++++++++++++++ libOpenCL.bp | 42 ++++++++++++++++++++++++++++++++++++ libOpenCLDriverStub.bp | 42 ++++++++++++++++++++++++++++++++++++ 5 files changed, 212 insertions(+) create mode 100644 Android.bp create mode 100644 icd_loader_test.bp create mode 100644 libIcdLog.bp create mode 100644 libOpenCL.bp create mode 100644 libOpenCLDriverStub.bp diff --git a/Android.bp b/Android.bp new file mode 100644 index 0000000..0464fed --- /dev/null +++ b/Android.bp @@ -0,0 +1,40 @@ +cc_defaults { + name: "OpenCL-ICD-Loader-defaults", + + vendor_available: true, + + 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/igc/include/third_party/opencl_headers", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} + + +build = [ + "libOpenCL.bp", + "libIcdLog.bp", + "libOpenCLDriverStub.bp", + "icd_loader_test.bp", +] \ No newline at end of file diff --git a/icd_loader_test.bp b/icd_loader_test.bp new file mode 100644 index 0000000..3dc4982 --- /dev/null +++ b/icd_loader_test.bp @@ -0,0 +1,49 @@ +cc_binary { + name: "icd_loader_test", + + vendor_available: 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: [ + "-O3", + "-DNDEBUG", + "-DCL_TARGET_OPENCL_VERSION=220", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "inc", + "test/inc", + ], + + shared_libs: [ + "libOpenCL", + "libIcdLog", + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/libIcdLog.bp b/libIcdLog.bp new file mode 100644 index 0000000..761437c --- /dev/null +++ b/libIcdLog.bp @@ -0,0 +1,39 @@ +cc_library_shared { + name: "libIcdLog", + + vendor_available: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/log/icd_test_log.c", + ], + + cflags: [ + "-O3", + "-DNDEBUG", + "-fPIC", + "-DCL_TARGET_OPENCL_VERSION=220", + "-DIcdLog_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "inc", + "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..1b6cd27 --- /dev/null +++ b/libOpenCL.bp @@ -0,0 +1,42 @@ +cc_library_shared { + name: "libOpenCL", + + vendor_available: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "loader/icd.c", + "loader/icd_dispatch.c", + "loader/linux/icd_linux.c", + "loader/linux/icd_linux_envvars.c", + ], + + cflags: [ + "-O3", + "-DNDEBUG", + "-fPIC", + "-DCL_TARGET_OPENCL_VERSION=220", + "-DOpenCL_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "inc", + "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..59f5d1a --- /dev/null +++ b/libOpenCLDriverStub.bp @@ -0,0 +1,42 @@ +cc_library_shared { + name: "libOpenCLDriverStub", + + vendor_available: 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: [ + "-O3", + "-DNDEBUG", + "-fPIC", + "-DCL_TARGET_OPENCL_VERSION=220", + "-DOpenCLDriverStub_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "inc", + "test/inc", + ], + + shared_libs: [ + "libIcdLog", + ], + + static_libs: [ + + ], + +} \ No newline at end of file From 094714453d36b0277ea45598be878e7026434f43 Mon Sep 17 00:00:00 2001 From: dengliqiang Date: Wed, 18 Sep 2019 00:32:25 +0800 Subject: [PATCH 04/13] corrected the path of 'opencl_headers' --- Android.bp | 2 +- scripts/icdloadergenerator.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Android.bp b/Android.bp index 0464fed..3788ac3 100644 --- a/Android.bp +++ b/Android.bp @@ -18,7 +18,7 @@ cc_defaults { ], include_dirs: [ - "hardware/intel/external/opencl/igc/include/third_party/opencl_headers", + "hardware/intel/external/opencl/compute-runtime/third_party/opencl_headers", ], shared_libs: [ diff --git a/scripts/icdloadergenerator.py b/scripts/icdloadergenerator.py index dc00a04..62a634f 100755 --- a/scripts/icdloadergenerator.py +++ b/scripts/icdloadergenerator.py @@ -48,7 +48,7 @@ def __init__(self, root): 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/igc/include/third_party/opencl_headers"], + 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): From d165ea2574f5358549c53416762e3998aed93f24 Mon Sep 17 00:00:00 2001 From: dengliqiang Date: Wed, 18 Sep 2019 00:37:38 +0800 Subject: [PATCH 05/13] cleaned redundant comment and updated printing message --- bp/icd-loader.tpl | 27 --------------------------- scripts/cleanicdloadergenerator.py | 4 ++-- 2 files changed, 2 insertions(+), 29 deletions(-) diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl index 6b537e1..718160a 100755 --- a/bp/icd-loader.tpl +++ b/bp/icd-loader.tpl @@ -18,33 +18,6 @@ # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # -# The file-tree of OpenCL-ICD-Loader -# OpenCL-ICD-Loader (cmake -DCMAKE_BUILD_TYPE=Release OpenCL-ICD-Loader) -# | -# +---- libOpenCL.so.1.2 -> Tools/Android/build/icd-loader/CMakeFiles/OpenCL.dir -# | -# +---- test -# | -# +---- log -# | | -# | +---- libIcdLog.so -> Tools/Android/build/icd-loader/test/platform/CMakeFiles/IcdLog.dir -# | -# +---- loader_test -# | | -# | +---- icd_loader_test -> Tools/Android/build/icd-loader/test/loader_test/CMakeFiles/icd_loader_test.dir -# | | -# | => libOpenCL.so.1.2, libIcdLog.so -# | -# +---- driver_stub -# | -# +---- libOpenCLDriverStub.so -> Tools/Android/build/icd-loader/test/driver_stub/CMakeFiles/OpenCLDriverStub.dir -# | -# => libIcdLog.so -# -# About the detailed of soong-build-tools(cc package), please refer to: -# https://ci.android.com/builds/submitted/5357401/linux/latest/view/soong_build.html -# -# # library_static, library_shared, binary cc_@module { name: "@name", diff --git a/scripts/cleanicdloadergenerator.py b/scripts/cleanicdloadergenerator.py index d6523a7..818363f 100755 --- a/scripts/cleanicdloadergenerator.py +++ b/scripts/cleanicdloadergenerator.py @@ -35,8 +35,8 @@ def run(self): print("script = " + script) print("root = " + root) - # remove all middle & build files - print("It is removing build and middle-files for OpenCL-ICD-Loader ... ") + # 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 From 6bfa68104ef5547b660ee0bbecca6c1cc90b67e7 Mon Sep 17 00:00:00 2001 From: Wan Shuang Date: Thu, 12 Mar 2020 14:08:58 +0800 Subject: [PATCH 06/13] Upgraded Python2 scripts Upgraded Python2 scripts to Python 3 using 2to3 tool. This is to mitigrate security risks of Python2 deprecation. Signed-off-by: Wan Shuang Tracked-On: OAM-90214 --- scripts/androidbpgenerator.py | 16 ++++++++-------- scripts/cleanicdloadergenerator.py | 4 ++-- scripts/icdloadergenerator.py | 4 ++-- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/scripts/androidbpgenerator.py b/scripts/androidbpgenerator.py index 2ff92b8..98587be 100755 --- a/scripts/androidbpgenerator.py +++ b/scripts/androidbpgenerator.py @@ -134,7 +134,7 @@ def generate(self, to_cmake = True, to_make = False): allBPs = {} # sub-module" .bp - for k in self.allmoduleinfo.keys(): + 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 @@ -143,20 +143,20 @@ def generate(self, to_cmake = True, to_make = False): # remove all comment tpl = re.sub("#.*\n", "", tpl).strip() # an Android.bp is related to some module - if bp in allBPs.keys(): + 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 allBPs.keys(): + 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.") + print((bp + " has been generated.")) #virtuall functions def getTemplate(self): @@ -217,7 +217,7 @@ def generateMakefile(self, debug=False, make=False): cmd += "cd " + builddir + " && " + self.getCmakeCmd() + verbose # need to make this project if make: - print("It is making: " + self.src) + print(("It is making: " + self.src)) cmd += "make -j$(nproc)" os.system(cmd) @@ -246,7 +246,7 @@ def getIncludes(self, mode, title): return "\n".join(includesfile) if includesfile else "" def getDefines(self, mode, title): - if not mode in self.allmoduleinfo.keys(): + 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) @@ -270,7 +270,7 @@ def getDefines(self, mode, title): return all_defines def getSources(self, mode): - if not mode in self.allmoduleinfo.keys(): + 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) @@ -286,7 +286,7 @@ def getSources(self, mode): return INDENT * 2 + "".join(lines).strip() def getLibrary(self, mode, reg1, reg2, reg3): - if not mode in self.allmoduleinfo.keys(): + 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) diff --git a/scripts/cleanicdloadergenerator.py b/scripts/cleanicdloadergenerator.py index 818363f..63cd24d 100755 --- a/scripts/cleanicdloadergenerator.py +++ b/scripts/cleanicdloadergenerator.py @@ -32,8 +32,8 @@ def run(self): script = path.dirname(__file__) root = path.abspath(path.join(script, "../..")) - print("script = " + script) - print("root = " + root) + 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 ... ") diff --git a/scripts/icdloadergenerator.py b/scripts/icdloadergenerator.py index 62a634f..012bff6 100755 --- a/scripts/icdloadergenerator.py +++ b/scripts/icdloadergenerator.py @@ -66,8 +66,8 @@ def run(self): script = path.dirname(__file__) root = path.abspath(path.join(script, "../..")) - print("script = " + script) - print("root = " + root) + print(("script = " + script)) + print(("root = " + root)) ICDLoaderGenerator(root).generate() From 195478fbcd7e51a1561fc35eb5cac7a6f67315c3 Mon Sep 17 00:00:00 2001 From: Wan Shuang Date: Thu, 13 Aug 2020 01:01:42 +0800 Subject: [PATCH 07/13] Make the libOpenCL accessible to vendor domain. Let libOpenCL relevant share libraries to be part of VNDK, so that vendor domain could link it at runtime dynamically. Change-Id: Ibc37f501b669d76b3f89e5f1ecbad15bbba433c8 Tracked-On: OAM-92070 Signed-off-by: Wan Shuang --- Android.bp | 5 ++++- bp/defaults.tpl | 5 ++++- bp/icd-loader.tpl | 5 ++++- icd_loader_test.bp | 5 ++++- libIcdLog.bp | 5 ++++- libOpenCL.bp | 5 ++++- libOpenCLDriverStub.bp | 6 +++++- 7 files changed, 29 insertions(+), 7 deletions(-) diff --git a/Android.bp b/Android.bp index 3788ac3..273b6b9 100644 --- a/Android.bp +++ b/Android.bp @@ -2,6 +2,9 @@ cc_defaults { name: "OpenCL-ICD-Loader-defaults", vendor_available: true, + vndk: { + enabled: true, + }, cflags: [ "-Wno-error", @@ -37,4 +40,4 @@ build = [ "libIcdLog.bp", "libOpenCLDriverStub.bp", "icd_loader_test.bp", -] \ No newline at end of file +] diff --git a/bp/defaults.tpl b/bp/defaults.tpl index 9730967..93f1f37 100755 --- a/bp/defaults.tpl +++ b/bp/defaults.tpl @@ -22,6 +22,9 @@ cc_defaults { name: "@name", vendor_available: true, + vndk: { + enabled: true, + }, cflags: [ @cflags @@ -52,4 +55,4 @@ cc_defaults { build = [ @build -] \ No newline at end of file +] diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl index 718160a..6907bf0 100755 --- a/bp/icd-loader.tpl +++ b/bp/icd-loader.tpl @@ -23,6 +23,9 @@ cc_@module { name: "@name", vendor_available: true, + vndk: { + enabled: true, + }, defaults: [ @defaults @@ -52,4 +55,4 @@ cc_@module { @static_libs ], -} \ No newline at end of file +} diff --git a/icd_loader_test.bp b/icd_loader_test.bp index 3dc4982..386de5f 100644 --- a/icd_loader_test.bp +++ b/icd_loader_test.bp @@ -2,6 +2,9 @@ cc_binary { name: "icd_loader_test", vendor_available: true, + vndk: { + enabled: true, + }, defaults: [ "OpenCL-ICD-Loader-defaults", @@ -46,4 +49,4 @@ cc_binary { ], -} \ No newline at end of file +} diff --git a/libIcdLog.bp b/libIcdLog.bp index 761437c..f280d1a 100644 --- a/libIcdLog.bp +++ b/libIcdLog.bp @@ -2,6 +2,9 @@ cc_library_shared { name: "libIcdLog", vendor_available: true, + vndk: { + enabled: true, + }, defaults: [ "OpenCL-ICD-Loader-defaults", @@ -36,4 +39,4 @@ cc_library_shared { ], -} \ No newline at end of file +} diff --git a/libOpenCL.bp b/libOpenCL.bp index 1b6cd27..38cbd6b 100644 --- a/libOpenCL.bp +++ b/libOpenCL.bp @@ -2,6 +2,9 @@ cc_library_shared { name: "libOpenCL", vendor_available: true, + vndk: { + enabled: true, + }, defaults: [ "OpenCL-ICD-Loader-defaults", @@ -39,4 +42,4 @@ cc_library_shared { ], -} \ No newline at end of file +} diff --git a/libOpenCLDriverStub.bp b/libOpenCLDriverStub.bp index 59f5d1a..57c18d6 100644 --- a/libOpenCLDriverStub.bp +++ b/libOpenCLDriverStub.bp @@ -3,6 +3,10 @@ cc_library_shared { vendor_available: true, + vndk: { + enabled: true, + }, + defaults: [ "OpenCL-ICD-Loader-defaults", ], @@ -39,4 +43,4 @@ cc_library_shared { ], -} \ No newline at end of file +} From b7096d7e1cb1590ef34d70c9ffa7c06992a45765 Mon Sep 17 00:00:00 2001 From: Wan Shuang Date: Mon, 24 Aug 2020 09:43:50 +0800 Subject: [PATCH 08/13] Remove vndk mode for openCL libraries. VNDK mode breaks the API locked branches, so remove the vndk mode. Change-Id: Id4e7cc1241b08b82dea3d655f15a278673df68ae Tracked-On: OAM-92270 Signed-off-by: Wan Shuang --- Android.bp | 5 +---- bp/defaults.tpl | 5 +---- bp/icd-loader.tpl | 5 +---- icd_loader_test.bp | 5 +---- libIcdLog.bp | 5 +---- libOpenCL.bp | 5 +---- libOpenCLDriverStub.bp | 6 +----- 7 files changed, 7 insertions(+), 29 deletions(-) diff --git a/Android.bp b/Android.bp index 273b6b9..dadf466 100644 --- a/Android.bp +++ b/Android.bp @@ -1,10 +1,7 @@ cc_defaults { name: "OpenCL-ICD-Loader-defaults", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, cflags: [ "-Wno-error", diff --git a/bp/defaults.tpl b/bp/defaults.tpl index 93f1f37..eb5c087 100755 --- a/bp/defaults.tpl +++ b/bp/defaults.tpl @@ -21,10 +21,7 @@ cc_defaults { name: "@name", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, cflags: [ @cflags diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl index 6907bf0..5c6632e 100755 --- a/bp/icd-loader.tpl +++ b/bp/icd-loader.tpl @@ -22,10 +22,7 @@ cc_@module { name: "@name", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, defaults: [ @defaults diff --git a/icd_loader_test.bp b/icd_loader_test.bp index 386de5f..e60a3d7 100644 --- a/icd_loader_test.bp +++ b/icd_loader_test.bp @@ -1,10 +1,7 @@ cc_binary { name: "icd_loader_test", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, defaults: [ "OpenCL-ICD-Loader-defaults", diff --git a/libIcdLog.bp b/libIcdLog.bp index f280d1a..d8f28cf 100644 --- a/libIcdLog.bp +++ b/libIcdLog.bp @@ -1,10 +1,7 @@ cc_library_shared { name: "libIcdLog", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, defaults: [ "OpenCL-ICD-Loader-defaults", diff --git a/libOpenCL.bp b/libOpenCL.bp index 38cbd6b..b677a8f 100644 --- a/libOpenCL.bp +++ b/libOpenCL.bp @@ -1,10 +1,7 @@ cc_library_shared { name: "libOpenCL", - vendor_available: true, - vndk: { - enabled: true, - }, + vendor: true, defaults: [ "OpenCL-ICD-Loader-defaults", diff --git a/libOpenCLDriverStub.bp b/libOpenCLDriverStub.bp index 57c18d6..bb8d283 100644 --- a/libOpenCLDriverStub.bp +++ b/libOpenCLDriverStub.bp @@ -1,11 +1,7 @@ cc_library_shared { name: "libOpenCLDriverStub", - vendor_available: true, - - vndk: { - enabled: true, - }, + vendor: true, defaults: [ "OpenCL-ICD-Loader-defaults", From caa9f71bd45eebdf9c3c58a7b18a5940f186006a Mon Sep 17 00:00:00 2001 From: buildslave Date: Wed, 20 Jul 2022 15:35:03 +0530 Subject: [PATCH 09/13] Added Github Workflows --- .github/workflows/Runchecks.yaml | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) create mode 100644 .github/workflows/Runchecks.yaml diff --git a/.github/workflows/Runchecks.yaml b/.github/workflows/Runchecks.yaml new file mode 100644 index 0000000..63e287c --- /dev/null +++ b/.github/workflows/Runchecks.yaml @@ -0,0 +1,17 @@ +--- +name: Run CheckApproval CheckBug CheckLint tasks + +on: + pull_request: + types: [opened, synchronize, reopened, labeled] + branches: "**" + pull_request_review: + types: [submitted] + branches: "**" +jobs: + TriggerWorkfows: + uses: projectceladon/celadonworkflows/.github/workflows/Triggerall.yml@main + with: + PR_EVENT: ${{ github.event.action }} + PR_URL: https://github.com/${{github.repository}}/pull/${{ github.event.pull_request.number }} + PR_LABEL: ${{ github.event.label.name }} From 5074d06714243b1621985c383af3761bfcff9d2f Mon Sep 17 00:00:00 2001 From: "Mastan, ShaikX Shahbaz" Date: Fri, 2 Jun 2023 15:50:06 +0530 Subject: [PATCH 10/13] Added Github Workflows --- .github/workflows/run_ci_checks.yaml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) create mode 100644 .github/workflows/run_ci_checks.yaml diff --git a/.github/workflows/run_ci_checks.yaml b/.github/workflows/run_ci_checks.yaml new file mode 100644 index 0000000..38c3846 --- /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: "**" +jobs: + TriggerWorkfows: + uses: projectceladon/celadonworkflows/.github/workflows/trigger_ci.yml@v1.0 + with: + EVENT: ${{ toJSON(github.event) }} From 3e7cff4ab1eac48d937ca5a677a1ecd7262c9c15 Mon Sep 17 00:00:00 2001 From: "Mastan, ShaikX Shahbaz" Date: Fri, 2 Jun 2023 15:50:07 +0530 Subject: [PATCH 11/13] Added Github Workflows --- .github/workflows/Runchecks.yaml | 17 ----------------- 1 file changed, 17 deletions(-) delete mode 100644 .github/workflows/Runchecks.yaml diff --git a/.github/workflows/Runchecks.yaml b/.github/workflows/Runchecks.yaml deleted file mode 100644 index 63e287c..0000000 --- a/.github/workflows/Runchecks.yaml +++ /dev/null @@ -1,17 +0,0 @@ ---- -name: Run CheckApproval CheckBug CheckLint tasks - -on: - pull_request: - types: [opened, synchronize, reopened, labeled] - branches: "**" - pull_request_review: - types: [submitted] - branches: "**" -jobs: - TriggerWorkfows: - uses: projectceladon/celadonworkflows/.github/workflows/Triggerall.yml@main - with: - PR_EVENT: ${{ github.event.action }} - PR_URL: https://github.com/${{github.repository}}/pull/${{ github.event.pull_request.number }} - PR_LABEL: ${{ github.event.label.name }} From fb289fe0670880b391a900c0c6a283392f5dc951 Mon Sep 17 00:00:00 2001 From: buildslave Date: Thu, 15 Feb 2024 11:51:41 +0000 Subject: [PATCH 12/13] updated workflows for OpenSSF compilance --- .github/workflows/run_ci_checks.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/run_ci_checks.yaml b/.github/workflows/run_ci_checks.yaml index 38c3846..e4667df 100644 --- a/.github/workflows/run_ci_checks.yaml +++ b/.github/workflows/run_ci_checks.yaml @@ -1,6 +1,5 @@ --- name: Run CI checks - on: pull_request: types: "**" @@ -8,6 +7,7 @@ on: pull_request_review: types: "**" branches: "**" +permissions: read-all jobs: TriggerWorkfows: uses: projectceladon/celadonworkflows/.github/workflows/trigger_ci.yml@v1.0 From 4c186491953f119dd00624eabedc98702cba7213 Mon Sep 17 00:00:00 2001 From: "Mi, Yanfeng" Date: Wed, 24 Apr 2024 15:20:24 +0800 Subject: [PATCH 13/13] Upgrade OpenCL ICD loader needed for OpenCL enabling on GEN12+ Tracked-On: OAM-117839 Signed-off-by: Mi, Yanfeng --- Android.bp | 3 +- CMakeLists.txt | 258 +- OpenCL.pc.in | 9 + README.md | 112 +- clinfo.bp | 34 + clinfo/OpenCLInfo.cpp | 815 +++ cmake/JoinPaths.cmake | 26 + icd_loader_test.bp | 8 +- inc/README.txt | 1 - libIcdLog.bp | 8 +- libOpenCL.bp | 14 +- libOpenCLDriverStub.bp | 8 +- loader/cllayerinfo.c | 132 + loader/icd.c | 183 +- loader/icd.h | 161 +- loader/icd_dispatch.c | 2803 +-------- loader/icd_dispatch.h | 1432 +---- loader/icd_dispatch_generated.c | 7034 ++++++++++++++++++++++ loader/icd_platform.h | 17 +- loader/icd_version.h | 57 + loader/linux/icd_exports.map | 7 + loader/linux/icd_linux.c | 261 +- loader/linux/icd_linux_envvars.c | 23 +- loader/windows/OpenCL-mingw-i686.def | 162 + loader/windows/OpenCL.def | 4 + loader/windows/OpenCL.rc | 20 +- loader/windows/adapter.h | 80 + loader/windows/icd_windows.c | 333 +- loader/windows/icd_windows.h | 46 + loader/windows/icd_windows_apppackage.c | 123 + loader/windows/icd_windows_apppackage.h | 22 + loader/windows/icd_windows_dxgk.c | 183 +- loader/windows/icd_windows_dxgk.h | 1 + loader/windows/icd_windows_envvars.c | 31 + loader/windows/icd_windows_hkr.c | 75 +- loader/windows/icd_windows_hkr.h | 1 + scripts/.gitignore | 2 + scripts/README.md | 35 + scripts/gen/__init__.py | 130 + scripts/gen_loader.py | 43 + scripts/gen_print_layer.py | 43 + scripts/icd_dispatch_generated.c.mako | 489 ++ scripts/icd_print_layer_generated.c.mako | 310 + test/CMakeLists.txt | 42 +- test/driver_stub/CMakeLists.txt | 6 +- test/driver_stub/cl.c | 79 +- test/driver_stub/cl_ext.c | 2 +- test/driver_stub/cl_gl.c | 3 +- test/driver_stub/icd.c | 67 +- test/driver_stub/rename_api.h | 3 + test/inc/platform/icd_test_log.h | 14 +- test/layer/CMakeLists.txt | 22 + test/layer/icd_print_layer.c | 92 + test/layer/icd_print_layer.def | 3 + test/layer/icd_print_layer.h | 63 + test/layer/icd_print_layer.map | 8 + test/layer/icd_print_layer_generated.c | 2746 +++++++++ test/loader_test/CMakeLists.txt | 7 +- test/loader_test/callbacks.c | 5 + test/loader_test/icd_test_match.c | 6 +- test/loader_test/main.c | 2 + test/loader_test/param_struct.h | 36 +- test/loader_test/test_buffer_object.c | 2 +- test/loader_test/test_cl_runtime.c | 11 +- test/loader_test/test_clgl.c | 140 +- test/loader_test/test_create_calls.c | 96 +- test/loader_test/test_image_objects.c | 44 +- test/loader_test/test_kernel.c | 10 +- test/loader_test/test_platforms.c | 136 +- test/loader_test/test_program_objects.c | 25 +- test/loader_test/test_sampler_objects.c | 6 +- test/log/CMakeLists.txt | 6 +- test/pkgconfig/bare/CMakeLists.txt | 41 + test/pkgconfig/pkgconfig.c | 56 + test/pkgconfig/pkgconfig/CMakeLists.txt | 55 + test/pkgconfig/sdk/CMakeLists.txt | 40 + 76 files changed, 14854 insertions(+), 4559 deletions(-) create mode 100644 OpenCL.pc.in create mode 100644 clinfo.bp create mode 100755 clinfo/OpenCLInfo.cpp create mode 100644 cmake/JoinPaths.cmake create mode 100644 loader/cllayerinfo.c create mode 100644 loader/icd_dispatch_generated.c create mode 100644 loader/icd_version.h create mode 100644 loader/windows/OpenCL-mingw-i686.def create mode 100644 loader/windows/adapter.h create mode 100644 loader/windows/icd_windows.h create mode 100644 loader/windows/icd_windows_apppackage.c create mode 100644 loader/windows/icd_windows_apppackage.h create mode 100644 scripts/.gitignore create mode 100644 scripts/README.md create mode 100644 scripts/gen/__init__.py create mode 100644 scripts/gen_loader.py create mode 100644 scripts/gen_print_layer.py create mode 100644 scripts/icd_dispatch_generated.c.mako create mode 100644 scripts/icd_print_layer_generated.c.mako create mode 100644 test/layer/CMakeLists.txt create mode 100644 test/layer/icd_print_layer.c create mode 100644 test/layer/icd_print_layer.def create mode 100644 test/layer/icd_print_layer.h create mode 100644 test/layer/icd_print_layer.map create mode 100644 test/layer/icd_print_layer_generated.c create mode 100644 test/pkgconfig/bare/CMakeLists.txt create mode 100644 test/pkgconfig/pkgconfig.c create mode 100644 test/pkgconfig/pkgconfig/CMakeLists.txt create mode 100644 test/pkgconfig/sdk/CMakeLists.txt diff --git a/Android.bp b/Android.bp index dadf466..c573936 100644 --- a/Android.bp +++ b/Android.bp @@ -14,7 +14,7 @@ cc_defaults { ], clang_cflags: [ - "-Wno-error=non-virtual-dtor", + ], include_dirs: [ @@ -37,4 +37,5 @@ build = [ "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/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 index e60a3d7..9017359 100644 --- a/icd_loader_test.bp +++ b/icd_loader_test.bp @@ -23,9 +23,8 @@ cc_binary { ], cflags: [ - "-O3", - "-DNDEBUG", - "-DCL_TARGET_OPENCL_VERSION=220", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", ], cppflags: [ @@ -33,7 +32,6 @@ cc_binary { ], local_include_dirs: [ - "inc", "test/inc", ], @@ -46,4 +44,4 @@ cc_binary { ], -} +} \ 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 index d8f28cf..ad9f887 100644 --- a/libIcdLog.bp +++ b/libIcdLog.bp @@ -12,10 +12,9 @@ cc_library_shared { ], cflags: [ - "-O3", - "-DNDEBUG", "-fPIC", - "-DCL_TARGET_OPENCL_VERSION=220", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", "-DIcdLog_EXPORTS", ], @@ -24,7 +23,6 @@ cc_library_shared { ], local_include_dirs: [ - "inc", "test/inc", ], @@ -36,4 +34,4 @@ cc_library_shared { ], -} +} \ No newline at end of file diff --git a/libOpenCL.bp b/libOpenCL.bp index b677a8f..cb11698 100644 --- a/libOpenCL.bp +++ b/libOpenCL.bp @@ -10,15 +10,20 @@ cc_library_shared { 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: [ - "-O3", - "-DNDEBUG", "-fPIC", - "-DCL_TARGET_OPENCL_VERSION=220", + "-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", ], @@ -27,7 +32,6 @@ cc_library_shared { ], local_include_dirs: [ - "inc", "loader", ], @@ -39,4 +43,4 @@ cc_library_shared { ], -} +} \ No newline at end of file diff --git a/libOpenCLDriverStub.bp b/libOpenCLDriverStub.bp index bb8d283..0f499bc 100644 --- a/libOpenCLDriverStub.bp +++ b/libOpenCLDriverStub.bp @@ -15,10 +15,9 @@ cc_library_shared { ], cflags: [ - "-O3", - "-DNDEBUG", "-fPIC", - "-DCL_TARGET_OPENCL_VERSION=220", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", "-DOpenCLDriverStub_EXPORTS", ], @@ -27,7 +26,6 @@ cc_library_shared { ], local_include_dirs: [ - "inc", "test/inc", ], @@ -39,4 +37,4 @@ cc_library_shared { ], -} +} \ 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 c7acc42..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,116 +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) { -#ifndef __ANDROID__ 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); } @@ -142,8 +209,22 @@ void khrIcdOsVendorsEnumerate(void) { khrIcd_free_getenv(envPath); } -#endif - khrIcdVendorAdd("/vendor/lib64/libigdrcl.so"); +} + +// 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 @@ -153,7 +234,7 @@ void khrIcdOsVendorsEnumerateOnce(void) } /* - * + * * Dynamic library loading functions * */ @@ -161,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. @@ -175,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 b71432e..ee6871a 100644 --- a/loader/linux/icd_linux_envvars.c +++ b/loader/linux/icd_linux_envvars.c @@ -21,11 +21,10 @@ #define _GNU_SOURCE #endif -#ifndef __ANDROID__ -#include "icd_cmake_config.h" -#endif +//#include "icd_cmake_config.h" #include +#include char *khrIcd_getenv(const char *name) { // No allocation of memory necessary for Linux. @@ -44,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/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/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}" +)