From c91de7a707e42da4047513d5e14c3c2072da99a5 Mon Sep 17 00:00:00 2001 From: "Mi, Yanfeng" Date: Sun, 28 Apr 2024 14:03:34 +0800 Subject: [PATCH 1/5] Add android bp files for rebase Tracked-On: OAM-117839 Signed-off-by: Mi, Yanfeng --- Android.bp | 39 ++++ bp/defaults.tpl | 55 +++++ bp/icd-loader.tpl | 55 +++++ libIcdLog.bp | 37 ++++ libOpenCL.bp | 46 +++++ libOpenCLDriverStub.bp | 40 ++++ scripts/androidbpgenerator.py | 313 +++++++++++++++++++++++++++++ scripts/cleanicdloadergenerator.py | 49 +++++ scripts/icdloadergenerator.py | 77 +++++++ 9 files changed, 711 insertions(+) create mode 100644 Android.bp create mode 100755 bp/defaults.tpl create mode 100755 bp/icd-loader.tpl create mode 100644 libIcdLog.bp create mode 100644 libOpenCL.bp create mode 100644 libOpenCLDriverStub.bp create mode 100755 scripts/androidbpgenerator.py create mode 100755 scripts/cleanicdloadergenerator.py create mode 100755 scripts/icdloadergenerator.py diff --git a/Android.bp b/Android.bp new file mode 100644 index 0000000..12cb854 --- /dev/null +++ b/Android.bp @@ -0,0 +1,39 @@ +cc_defaults { + name: "OpenCL-ICD-Loader-defaults", + + vendor: true, + + cflags: [ + "-Wno-error", + "-Wno-error=implicit-function-declaration", + "-DAMD64", + ], + + cppflags: [ + "-D__ANDROID__", + ], + + clang_cflags: [ + + ], + + include_dirs: [ + "hardware/intel/external/opencl/compute-runtime/third_party/opencl_headers", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} + + +build = [ + "libOpenCL.bp", + "libIcdLog.bp", + "libOpenCLDriverStub.bp", +] diff --git a/bp/defaults.tpl b/bp/defaults.tpl new file mode 100755 index 0000000..eb5c087 --- /dev/null +++ b/bp/defaults.tpl @@ -0,0 +1,55 @@ +# Copyright(c) 2019 Intel Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files(the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and / or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +# +cc_defaults { + name: "@name", + + vendor: true, + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + clang_cflags: [ +@clang_cflags + ], + + include_dirs: [ +@include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} + + +build = [ +@build +] diff --git a/bp/icd-loader.tpl b/bp/icd-loader.tpl new file mode 100755 index 0000000..5c6632e --- /dev/null +++ b/bp/icd-loader.tpl @@ -0,0 +1,55 @@ +# Copyright(c) 2019 Intel Corporation +# +# Permission is hereby granted, free of charge, to any person obtaining a +# copy of this software and associated documentation files(the "Software"), +# to deal in the Software without restriction, including without limitation +# the rights to use, copy, modify, merge, publish, distribute, sublicense, +# and / or sell copies of the Software, and to permit persons to whom the +# Software is furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +# OTHER DEALINGS IN THE SOFTWARE. +# +# library_static, library_shared, binary +cc_@module { + name: "@name", + + vendor: true, + + defaults: [ +@defaults + ], + + srcs: [ +@srcs + ], + + cflags: [ +@cflags + ], + + cppflags: [ +@cppflags + ], + + local_include_dirs: [ +@local_include_dirs + ], + + shared_libs: [ +@shared_libs + ], + + static_libs: [ +@static_libs + ], + +} diff --git a/libIcdLog.bp b/libIcdLog.bp new file mode 100644 index 0000000..ad9f887 --- /dev/null +++ b/libIcdLog.bp @@ -0,0 +1,37 @@ +cc_library_shared { + name: "libIcdLog", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/log/icd_test_log.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DIcdLog_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "test/inc", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/libOpenCL.bp b/libOpenCL.bp new file mode 100644 index 0000000..cb11698 --- /dev/null +++ b/libOpenCL.bp @@ -0,0 +1,46 @@ +cc_library_shared { + name: "libOpenCL", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "loader/icd.c", + "loader/icd_dispatch.c", + "loader/icd_dispatch_generated.c", + "loader/linux/icd_linux.c", + "loader/linux/icd_linux_envvars.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_ENABLE_LAYERS", + "-DCL_NO_NON_ICD_DISPATCH_EXTENSION_PROTOTYPES", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DOPENCL_ICD_LOADER_VERSION_MAJOR=3", + "-DOPENCL_ICD_LOADER_VERSION_MINOR=0", + "-DOPENCL_ICD_LOADER_VERSION_REV=6", + "-DOpenCL_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "loader", + ], + + shared_libs: [ + + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/libOpenCLDriverStub.bp b/libOpenCLDriverStub.bp new file mode 100644 index 0000000..0f499bc --- /dev/null +++ b/libOpenCLDriverStub.bp @@ -0,0 +1,40 @@ +cc_library_shared { + name: "libOpenCLDriverStub", + + vendor: true, + + defaults: [ + "OpenCL-ICD-Loader-defaults", + ], + + srcs: [ + "test/driver_stub/cl.c", + "test/driver_stub/cl_ext.c", + "test/driver_stub/cl_gl.c", + "test/driver_stub/icd.c", + ], + + cflags: [ + "-fPIC", + "-std=gnu99", + "-DCL_TARGET_OPENCL_VERSION=300", + "-DOpenCLDriverStub_EXPORTS", + ], + + cppflags: [ + + ], + + local_include_dirs: [ + "test/inc", + ], + + shared_libs: [ + "libIcdLog", + ], + + static_libs: [ + + ], + +} \ No newline at end of file diff --git a/scripts/androidbpgenerator.py b/scripts/androidbpgenerator.py new file mode 100755 index 0000000..98587be --- /dev/null +++ b/scripts/androidbpgenerator.py @@ -0,0 +1,313 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +""" + +import os +import os.path as path +import re + + +INDENT = " " +BUILD_DIR = "__build__" +TEMPLATE_DIR = "bp" +NOVERBOSE = " > /dev/null 2>&1;" + + +def remove(f): + cmd = "rm -f " + f + NOVERBOSE + os.system(cmd) + + +class CCDefaults: + # constructor + def __init__(self, proj, defname, cflags = [], cppflags = [], clang_cflags = [], + include_dirs = [], shared_libs = [], static_libs = [], bpfiles = []): + self.templ = path.join(proj, TEMPLATE_DIR) + self.proj = proj + self.default_name = defname + self.c_flag = cflags + self.cpp_flag = cppflags + self.clang_cflag = clang_cflags + self.include_dir = include_dirs + self.shared_lib = shared_libs + self.static_lib = static_libs + self.bp_file = bpfiles + + def getBpFilePath(self): + return path.join(self.proj, "Android.bp") + + #major function + def generate(self): + if path.exists(self.proj) == False: + raise Exception(self.proj + " not existed") + # read template + with open(path.join(self.templ, "defaults.tpl")) as f: + tpl = f.read() + # remove all comment + tpl = re.sub("#.*\n", "", tpl).strip() + # replacement + tpl = tpl.replace("@name", self.default_name) + tpl = tpl.replace("@cflags", self.convertList2Str(self.c_flag)) + tpl = tpl.replace("@cppflags", self.convertList2Str(self.cpp_flag)) + tpl = tpl.replace("@clang_cflags", self.convertList2Str(self.clang_cflag)) + tpl = tpl.replace("@include_dirs", self.convertList2Str(self.include_dir)) + tpl = tpl.replace("@shared_libs", self.convertList2Str(self.shared_lib)) + tpl = tpl.replace("@static_libs", self.convertList2Str(self.static_lib)) + tpl = tpl.replace("@build", self.convertList2Str(self.bp_file, indent_num = 1)) + + return tpl + + def convertList2Str(self, itemlist, indent_num = 2): + str = "" + + for i, t in enumerate(itemlist): + if 0 == len(t): + continue + str += INDENT * indent_num + "\"" + t + "\",\n" + + return INDENT * indent_num + "".join(str).strip() + + +class ModuleInfo: + # constructor + def __init__(self, modulename, bpfilename, cmakedir, moduletype, defaults, + middledir = "", addsrc = [], addflags = [], addstatic = [], addshared = [], + updateflags = {}, updatestatic = {}, updateshared = {}): + self.Module_Name = modulename # name of module + self.Bp_File_Name = bpfilename # BP file name + self.Mid_Dir = middledir # some middle directory + self.Build_Make = middledir + cmakedir + "build.make" # building file in directory generated by cmake + self.Flags_Make = middledir + cmakedir + "flags.make" # flag-file in directory generated by cmake + self.Module_Type = moduletype # support: cc_library_shared, cc_library_static + self.Defaults = INDENT * 2 + "\"" + defaults + "\"," + self.Add_Src = addsrc # some additional source files + self.Add_Flags = addflags # some additional cflags/cppflags + self.Add_Static = addstatic # some additional static library + self.Add_Shared = addshared # some additional shared library + self.Update_Flags = updateflags # update some cflags/cppflags + self.Update_Static = updatestatic # update the dependent static libraries + self.Update_Shared = updateshared # update the dependent static libraries + + +class Generator: + # constructor + def __init__(self, src, root): + # where is the major source file, and the directory to where *.bp should be put + self.src = src + # where to put build file and template + self.build = path.join(root, BUILD_DIR) + """where to put the template""" + self.templ = path.join(src, TEMPLATE_DIR) + # all submodule's info + self.allmoduleinfo = {} + # + # self.allmoduledefaults = CCDefaults(...) + + #major function + def generate(self, to_cmake = True, to_make = False): + if path.exists(self.src) == False: + raise Exception(self.src + " not existed") + + if to_cmake: + self.generateMakefile(make = to_make) + + self.adjustFiles() + + allBPs = {} + # sub-module" .bp + for k in list(self.allmoduleinfo.keys()): + # the path of Android.bp + bp = path.normpath(path.join(self.src, self.allmoduleinfo[k].Bp_File_Name)) + # read template + with open(self.getTemplatePath()) as f: + tpl = f.read() + # remove all comment + tpl = re.sub("#.*\n", "", tpl).strip() + # an Android.bp is related to some module + if bp in list(allBPs.keys()): + allBPs[bp] += "\n\n" + self.replaceTemplate(k, tpl) + else: + allBPs[bp] = self.replaceTemplate(k, tpl) + # Android.bp + allBPs[self.allmoduledefaults.getBpFilePath()] = self.allmoduledefaults.generate() + + for bp in list(allBPs.keys()): + # remove old Android.bp + remove(bp) + # create new Android.bp + with open(bp, "w") as f: + f.write(allBPs[bp]) + print((bp + " has been generated.")) + + #virtuall functions + def getTemplate(self): + raise Exception("pure virtul function") + + def replaceTemplate(self, mode, tpl): + tpl = tpl.replace("@module", self.allmoduleinfo[mode].Module_Type) + tpl = tpl.replace("@name", self.allmoduleinfo[mode].Module_Name) + tpl = tpl.replace("@defaults", self.allmoduleinfo[mode].Defaults) + tpl = tpl.replace("@srcs", self.getSources(mode)) + tpl = tpl.replace("@cflags", self.adjustFlags(mode, INDENT * 2 + "".join(self.getDefines(mode, "C_FLAGS") + self.getDefines(mode, "C_DEFINES")).strip(), is_add = False)) + tpl = tpl.replace("@cppflags", self.adjustFlags(mode, INDENT * 2 + "".join(self.getDefines(mode, "CXX_FLAGS") + self.getDefines(mode, "CXX_DEFINES")).strip())) + tpl = tpl.replace("@local_include_dirs", INDENT * 2 + "".join(self.getIncludes(mode, "C_INCLUDES") + "\n" + self.getIncludes(mode, "CXX_INCLUDES")).strip()) + tpl = tpl.replace("@shared_libs", INDENT * 2 + "".join(self.adjustLibrary(mode, self.getLibrary(mode, ".*?\\.so[.\d]*\\n", "\\.so)[.\d]*\\n", "\\.so[.\d]*"), False).strip())) + tpl = tpl.replace("@static_libs", INDENT * 2 + "".join(self.adjustLibrary(mode, self.getLibrary(mode, ".*?\\.a\\n", "\\.a)\\n", "\\.a")).strip())) + + return tpl + + def getName(self): + return self.getTemplate().split(".")[0] + + def getTemplatePath(self): + return path.join(self.templ, self.getTemplate()) + + def getBuildDir(self): + return path.join(self.build, self.getName()) + + def adjustSources(self, mode, all_sources): + return all_sources + + def adjustIncludes(self, mode, all_includes): + return all_includes + + def adjustFlags(self, mode, all_flags, is_add = True): + return all_flags + + def adjustLibrary(self, mode, all_libs, is_static = True): + return all_libs + + def adjustFiles(self): + return + + def getCmakeCmd(self): + return "cmake -DCMAKE_BUILD_TYPE=Release " + self.src + + def generateMakefile(self, debug=False, make=False): + #windows can help us debug the script and we do not want generate makefile on widnows + if os.name == "nt": + return + + verbose = ";" if debug else NOVERBOSE + builddir = self.getBuildDir() + # make quickly, but can't clear old makefile + cmd = "rm " + path.join(builddir, "CMakeCache.txt") + verbose + # clear old makefile, but need to cost some time + #cmd = "rm -rf " + builddir + verbose + cmd += "mkdir -p " + builddir + verbose + cmd += "cd " + builddir + " && " + self.getCmakeCmd() + verbose + # need to make this project + if make: + print(("It is making: " + self.src)) + cmd += "make -j$(nproc)" + + os.system(cmd) + + def getIncludes(self, mode, title): + includestext = self.getDefines(mode, title) + if (0 == len(includestext)): + return "" + + lines = includestext.split("\n") + includesfile = [] + + for l in lines: + if 0 == len(l): + continue + #normpath will make sure we did not refer outside. + p = path.normpath(l) + j = p.find(self.src) + # + if 0 <= j: + # check this path of include is existed, or not. + k = p[j:].find('"') + if (0 <= k) and (True == path.isdir(p[j : (j + k)])): + includesfile.append(p[j:].replace(self.src, INDENT * 2 + "\"")) + + return "\n".join(includesfile) if includesfile else "" + + def getDefines(self, mode, title): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + flagsfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Flags_Make) + with open(flagsfile) as f: + text = f.read() + + lines = re.findall(title + " =.*\n", text) + if (0 == len(lines)): + return "" + + all_defines = "" + + for i, l in enumerate(lines): + # 'strip' to remove the beginning and ending space + l = l.replace(title + " = ", "").strip() + if (0 == len(l)): + continue + + all_defines += INDENT * 2 + "\"" + re.sub(r"[ ]+", "\",\n" + INDENT * 2 + "\"", re.sub("=\"\"", "=", l)) + "\",\n" + + return all_defines + + def getSources(self, mode): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + buildfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Build_Make) + with open(buildfile) as f: + text = f.read() + + lines = re.findall(".*?: .*?CMakeFiles/.*?\\.dir/.*?\\.o\\n", text) + lines = [l.replace(".o", "\",") for l in lines] + + self.adjustSources(mode, lines) + + #make source pretty + return INDENT * 2 + "".join(lines).strip() + + def getLibrary(self, mode, reg1, reg2, reg3): + if not mode in list(self.allmoduleinfo.keys()): + raise Exception("Invalid index of module info") + + buildfile = path.join(self.getBuildDir(), self.allmoduleinfo[mode].Build_Make) + with open(buildfile) as f: + text = f.read() + + lines = re.findall(reg1, text) + if (0 == len(lines)): + return "" + + all_lib = "" + for i, l in enumerate(lines): + if 0 == len(l) or re.search("(?<=" + self.allmoduleinfo[mode].Module_Name + reg2, l): + continue + + j = l.rfind(": ") + if 0 > j: + continue + + l = l[(j + 2):] + j = l.rfind('/') + all_lib += INDENT * 2 + "\"" + re.sub(reg3, "\",", l[(j + 1):] if 0 <= j else l) + + return all_lib \ No newline at end of file diff --git a/scripts/cleanicdloadergenerator.py b/scripts/cleanicdloadergenerator.py new file mode 100755 index 0000000..63cd24d --- /dev/null +++ b/scripts/cleanicdloadergenerator.py @@ -0,0 +1,49 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +""" + +import os +import os.path as path +from androidbpgenerator import BUILD_DIR, NOVERBOSE + + +class Main: + + def run(self): + script = path.dirname(__file__) + root = path.abspath(path.join(script, "../..")) + + print(("script = " + script)) + print(("root = " + root)) + + # remove all intermediate files and building directories + print("It is removing building directories and intermediate files for OpenCL-ICD-Loader ... ") + cmd = "rm -rf " + path.join(script, "__pycache__") + NOVERBOSE + cmd += "rm -rf " + path.join(root, BUILD_DIR) + NOVERBOSE + #cmd += "find " + path.join(script, "..") + " -name '*\.bp' -type f -delete" + NOVERBOSE + os.system(cmd) + + print("Done ! ") + + +m = Main() +m.run() \ No newline at end of file diff --git a/scripts/icdloadergenerator.py b/scripts/icdloadergenerator.py new file mode 100755 index 0000000..012bff6 --- /dev/null +++ b/scripts/icdloadergenerator.py @@ -0,0 +1,77 @@ +#! /usr/bin/env python3 +""" +* Copyright (c) 2019, Intel Corporation +* +* Permission is hereby granted, free of charge, to any person obtaining a +* copy of this software and associated documentation files (the "Software"), +* to deal in the Software without restriction, including without limitation +* the rights to use, copy, modify, merge, publish, distribute, sublicense, +* and/or sell copies of the Software, and to permit persons to whom the +* Software is furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included +* in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR +* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +* OTHER DEALINGS IN THE SOFTWARE. +""" + +import os +import os.path as path +import re +from androidbpgenerator import INDENT, CCDefaults, ModuleInfo, Generator, NOVERBOSE + +RUN_CALLABLE = True + + +class ICDLoaderGenerator(Generator): + def __init__(self, root): + # It is necessary that patching on LLVM before generating Android.bp + self.proj = path.join(root, "OpenCL-ICD-Loader/") + super(ICDLoaderGenerator, self).__init__(self.proj, root) + + self.allmoduleinfo[0] = ModuleInfo("libOpenCL", "libOpenCL.bp", "CMakeFiles/OpenCL.dir/", + "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[1] = ModuleInfo("libIcdLog", "libIcdLog.bp", "test/log/CMakeFiles/IcdLog.dir/", + "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[2] = ModuleInfo("libOpenCLDriverStub", "libOpenCLDriverStub.bp", + "test/driver_stub/CMakeFiles/OpenCLDriverStub.dir/", "library_shared", "OpenCL-ICD-Loader-defaults") + self.allmoduleinfo[3] = ModuleInfo("icd_loader_test", "icd_loader_test.bp", + "test/loader_test/CMakeFiles/icd_loader_test.dir/", "binary", "OpenCL-ICD-Loader-defaults") + + self.allmoduledefaults = CCDefaults(self.proj, "OpenCL-ICD-Loader-defaults", + cflags = ["-Wno-error", "-Wno-error=implicit-function-declaration", "-DAMD64"], + cppflags = ["-D__ANDROID__"], + clang_cflags = ["-Wno-error=non-virtual-dtor"], + include_dirs = ["hardware/intel/external/opencl/compute-runtime/third_party/opencl_headers"], + bpfiles = ["libOpenCL.bp", "libIcdLog.bp", "libOpenCLDriverStub.bp", "icd_loader_test.bp"], ) + + def getTemplate(self): + return "icd-loader.tpl" + + def adjustSources(self, mode, all_sources): + for i, l in enumerate(all_sources): + all_sources[i] = INDENT * 2 + "\"" + re.sub(r".*?: " + self.allmoduleinfo[mode].Mid_Dir, "", + re.sub("CMakeFiles/.*?\\.dir/", "", l.replace("__/", "../"))) + + +class Main: + + def run(self): + script = path.dirname(__file__) + root = path.abspath(path.join(script, "../..")) + + print(("script = " + script)) + print(("root = " + root)) + + ICDLoaderGenerator(root).generate() + + +if RUN_CALLABLE: + m = Main() + m.run() \ No newline at end of file From f10be3cafa62d2f6635b50d6fd12a9e67ed29ee0 Mon Sep 17 00:00:00 2001 From: "Mi, Yanfeng" Date: Sun, 28 Apr 2024 14:24:58 +0800 Subject: [PATCH 2/5] Fix Android compiling issue Tracked-On: OAM-117839 Signed-off-by: Mi, Yanfeng --- loader/linux/icd_linux_envvars.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/loader/linux/icd_linux_envvars.c b/loader/linux/icd_linux_envvars.c index bfac87c..a0694d8 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 #include From 31b0a04eaff12ae8f8da96ce6bd31a612bdbd04e Mon Sep 17 00:00:00 2001 From: "Mi, Yanfeng" Date: Sun, 28 Apr 2024 14:33:18 +0800 Subject: [PATCH 3/5] Add clinfo for opencl platform checking Tracked-On: OAM-117839 Signed-off-by: Mi, Yanfeng --- Android.bp | 1 + clinfo.bp | 34 ++ clinfo/OpenCLInfo.cpp | 815 ++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 850 insertions(+) create mode 100644 clinfo.bp create mode 100755 clinfo/OpenCLInfo.cpp diff --git a/Android.bp b/Android.bp index 12cb854..c51fe5a 100644 --- a/Android.bp +++ b/Android.bp @@ -36,4 +36,5 @@ build = [ "libOpenCL.bp", "libIcdLog.bp", "libOpenCLDriverStub.bp", + "clinfo.bp", ] 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..ce400f7 --- /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; +} From c5a8ff9a5160a43dd44a6ce3ef27171e0d2fe665 Mon Sep 17 00:00:00 2001 From: sjshweta Date: Wed, 8 May 2024 11:19:03 +0530 Subject: [PATCH 4/5] Added github workflows for CI system --- .github/workflows/linux.yml | 342 --------------------------- .github/workflows/run_ci_checks.yaml | 15 ++ .github/workflows/windows.yml | 246 ------------------- 3 files changed, 15 insertions(+), 588 deletions(-) delete mode 100644 .github/workflows/linux.yml create mode 100644 .github/workflows/run_ci_checks.yaml delete mode 100644 .github/workflows/windows.yml diff --git a/.github/workflows/linux.yml b/.github/workflows/linux.yml deleted file mode 100644 index f301de6..0000000 --- a/.github/workflows/linux.yml +++ /dev/null @@ -1,342 +0,0 @@ -name: Linux - -on: [push, pull_request] - -env: - OPENCL_PKGCONFIG_PATHS: ${{ github.workspace }}/install/lib/pkgconfig:${{ github.workspace }}/external/OpenCL-Headers/install/share/pkgconfig - -jobs: - - tools: - runs-on: ubuntu-20.04 - strategy: - matrix: - CMAKE: [3.21.2] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{ matrix.CMAKE }}/cmake-${{ matrix.CMAKE }}-Linux-x86_64.tar.gz - - steps: - - name: Cache CMake - uses: actions/cache@v3 - id: cmake - env: - cache-name: cache-cmake - with: - path: ~/cmake-${{matrix.CMAKE}}-Linux-x86_64.tar.gz - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.CMAKE}} - - name: Checkout CMake - if: steps.cmake.outputs.cache-hit != 'true' - run: wget -c -O ~/cmake-${{matrix.CMAKE}}-Linux-x86_64.tar.gz $CMAKE_URL - - cmake-minimum: - runs-on: ${{ matrix.OS }} - container: streamhpc/opencl-sdk-base:ubuntu-18.04-20220127 - strategy: - matrix: - OS: [ubuntu-20.04] - COMPILER: [gcc-7, clang-8] #gcc-8 clang-10 - EXT: [ON, OFF] - GEN: [Unix Makefiles] - CONFIG: [Debug, Release] - STD: [99, 11] - BIN: [32, 64] - CMAKE: [3.1.3] #3.21.2 - env: - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - OPENCL_PKGCONFIG_PATHS: /__w/OpenCL-ICD-Loader/OpenCL-ICD-Loader/install/lib/pkgconfig:/__w/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/pkgconfig - - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v3 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v3 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -D BUILD_TESTING=OFF - -B$GITHUB_WORKSPACE/external/OpenCL-Headers/build - -H$GITHUB_WORKSPACE/external/OpenCL-Headers && - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - -- - -j`nproc` - - - name: Configure - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_FLAGS="-Wall -Wextra -Werror -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B$GITHUB_WORKSPACE/build - -H$GITHUB_WORKSPACE - - - name: Build - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - -- - -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: bash - run: $CTEST_EXE --output-on-failure --parallel `nproc` - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/libOpenCLDriverStub.so - -B$GITHUB_WORKSPACE/build/downstream/bare - -H$GITHUB_WORKSPACE/test/pkgconfig/bare ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/bare ; - cd $GITHUB_WORKSPACE/build/downstream/bare ; - $CTEST_EXE --output-on-failure - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e "include(\"$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake\")\ninclude(\"\${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake\")" > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_BUILD_TYPE=${{matrix.CONFIG}} - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/libOpenCLDriverStub.so - -B$GITHUB_WORKSPACE/build/downstream/sdk - -H$GITHUB_WORKSPACE/test/pkgconfig/sdk ; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/build/downstream/sdk ; - cd $GITHUB_WORKSPACE/build/downstream/sdk ; - $CTEST_EXE --output-on-failure - - - name: Test pkg-config --cflags - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" pkg-config OpenCL --cflags | grep -q "\-I$GITHUB_WORKSPACE/external/OpenCL-Headers/install/include" - - - name: Test pkg-config --libs - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" pkg-config OpenCL --libs | grep -q "\-L$GITHUB_WORKSPACE/install/lib -lOpenCL" - - - name: Consume pkg-config - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/libOpenCLDriverStub.so - -B$GITHUB_WORKSPACE/build/downstream/pkgconfig - -H$GITHUB_WORKSPACE/test/pkgconfig/pkgconfig ; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/pkgconfig ; - cd $GITHUB_WORKSPACE/build/downstream/pkgconfig ; - $CTEST_EXE --output-on-failure - - - - - - cmake-latest: - needs: [tools] - runs-on: ${{ matrix.OS }} - strategy: - matrix: - OS : [ubuntu-20.04] - COMPILER: [gcc-9, gcc-11, clang-11, clang-13] - EXT: [ON, OFF] - GEN: [Ninja Multi-Config] - STD: [99, 11, 17] - BIN: [32, 64] - CMAKE: [3.21.2] - env: - CMAKE_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/cmake - CTEST_EXE: /opt/Kitware/CMake/${{ matrix.CMAKE }}/bin/ctest - - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v3 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v3 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Restore CMake - uses: actions/cache@v3 - id: cmake - env: - cache-name: cache-cmake - with: - path: ~/cmake-${{matrix.CMAKE}}-Linux-x86_64.tar.gz - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.CMAKE}} - - - name: Create Build Environment - run: sudo apt-get update -q; - if [[ "${{matrix.GEN}}" =~ "Ninja" && ! `which ninja` ]]; then sudo apt install -y ninja-build; fi; - if [[ "${{matrix.COMPILER}}" =~ "gcc-11" ]]; then sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test; fi; - if [[ "${{matrix.COMPILER}}" =~ "clang-13" ]]; then wget -q -O - https://apt.llvm.org/llvm-snapshot.gpg.key | sudo apt-key add -; sudo apt-add-repository -y 'deb [arch=amd64] https://apt.llvm.org/focal/ llvm-toolchain-focal-13 main'; fi; - sudo apt install -y ${{matrix.COMPILER}}; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "gcc" ]]; then sudo apt install -y ${{matrix.COMPILER}}-multilib; fi; - if [[ "${{matrix.BIN}}" == "32" && "${{matrix.COMPILER}}" =~ "clang" ]]; then sudo apt install -y gcc-multilib ; fi; - mkdir -p /opt/Kitware/CMake; - tar -xzf ~/cmake-${{matrix.CMAKE}}-Linux-x86_64.tar.gz --directory /opt/Kitware/CMake; - mv /opt/Kitware/CMake/cmake-${{ matrix.CMAKE }}-* /opt/Kitware/CMake/${{ matrix.CMAKE }} - # Install Ninja only if it's the selected generator and it's not available. - - - name: Build & install OpenCL-Headers - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_FLAGS="-w -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -D BUILD_TESTING=OFF - -B $GITHUB_WORKSPACE/external/OpenCL-Headers/build - -S $GITHUB_WORKSPACE/external/OpenCL-Headers; - $CMAKE_EXE - --build $GITHUB_WORKSPACE/external/OpenCL-Headers/build - --target install - --config Release - -- - -j`nproc` - - - name: Configure - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D BUILD_TESTING=ON - -D CMAKE_C_FLAGS="-Wall -Wextra -Werror -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_INSTALL_PREFIX=$GITHUB_WORKSPACE/install - -D CMAKE_PREFIX_PATH=$GITHUB_WORKSPACE/external/OpenCL-Headers/install - -B $GITHUB_WORKSPACE/build - -S $GITHUB_WORKSPACE - - - name: Build - shell: bash - run: | - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Release -- -j`nproc`; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build --config Debug -- -j`nproc` - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: bash - run: | - $CTEST_EXE --output-on-failure -C Release --parallel `nproc`; - $CTEST_EXE --output-on-failure -C Debug --parallel `nproc`; - - - name: Install - shell: bash - run: $CMAKE_EXE - --build $GITHUB_WORKSPACE/build - --target install - --config Release - -- - -j`nproc` - - - name: "Consume (standalone): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.so - -B $GITHUB_WORKSPACE/build/downstream/bare - -S $GITHUB_WORKSPACE/test/pkgconfig/bare; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/bare --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/bare; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; - - - name: "Consume (SDK): Configure/Build/Test" - shell: bash - run: $CMAKE_EXE -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL ; - echo -e "include(\"$GITHUB_WORKSPACE/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake\")\ninclude(\"\${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake\")" > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake ; - $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D CMAKE_PREFIX_PATH="$GITHUB_WORKSPACE/external/OpenCL-Headers/install;$GITHUB_WORKSPACE/install" - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.so - -B $GITHUB_WORKSPACE/build/downstream/sdk - -S $GITHUB_WORKSPACE/test/pkgconfig/sdk; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/sdk --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/sdk; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; - - - name: Test pkg-config --cflags - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" pkg-config OpenCL --cflags | grep -q "\-I$GITHUB_WORKSPACE/external/OpenCL-Headers/install/include" - - - name: Test pkg-config --libs - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" pkg-config OpenCL --libs | grep -q "\-L$GITHUB_WORKSPACE/install/lib -lOpenCL" - - - name: Consume pkg-config - shell: bash - run: PKG_CONFIG_PATH="$OPENCL_PKGCONFIG_PATHS" $CMAKE_EXE - -G "${{matrix.GEN}}" - -D CMAKE_C_COMPILER=${{matrix.COMPILER}} - -D CMAKE_C_FLAGS="-Wall -Wextra -pedantic -m${{matrix.BIN}}" - -D CMAKE_C_STANDARD=${{matrix.STD}} - -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} - -D DRIVER_STUB_PATH=$GITHUB_WORKSPACE/build/Release/libOpenCLDriverStub.so - -B $GITHUB_WORKSPACE/build/downstream/pkgconfig - -S $GITHUB_WORKSPACE/test/pkgconfig/pkgconfig; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/pkgconfig --config Release; - $CMAKE_EXE --build $GITHUB_WORKSPACE/build/downstream/pkgconfig --config Debug; - cd $GITHUB_WORKSPACE/build/downstream/pkgconfig; - $CTEST_EXE --output-on-failure -C Release; - $CTEST_EXE --output-on-failure -C Debug; diff --git a/.github/workflows/run_ci_checks.yaml b/.github/workflows/run_ci_checks.yaml new file mode 100644 index 0000000..30c59f1 --- /dev/null +++ b/.github/workflows/run_ci_checks.yaml @@ -0,0 +1,15 @@ +--- +name: Run CI checks +on: + pull_request: + types: "**" + branches: "**" + pull_request_review: + types: "**" + branches: "**" +permissions: read-all +jobs: + TriggerWorkfows: + uses: projectceladon/celadonworkflows/.github/workflows/trigger_ci.yml@v1.0 + with: + EVENT: ${{ toJSON(github.event) }} \ No newline at end of file diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml deleted file mode 100644 index 407a7e2..0000000 --- a/.github/workflows/windows.yml +++ /dev/null @@ -1,246 +0,0 @@ -name: Windows - -on: [push, pull_request] - -jobs: - - tools: - runs-on: windows-2022 - strategy: - matrix: - CMAKE: [3.22.0] - NINJA: [1.10.2] - env: - CMAKE_URL: https://github.com/Kitware/CMake/releases/download/v${{matrix.CMAKE}}/cmake-${{matrix.CMAKE}}-windows-x86_64.zip - NINJA_URL: https://github.com/ninja-build/ninja/releases/download/v${{matrix.NINJA}}/ninja-win.zip - - steps: - - name: Cache CMake - uses: actions/cache@v3 - id: cmake - env: - cache-name: cache-cmake - with: - path: ~/Downloads/cmake-${{matrix.CMAKE}}-windows-x86_64.zip - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.CMAKE}} - - name: Cache Ninja - uses: actions/cache@v3 - id: ninja - env: - cache-name: cache-ninja - with: - path: ~/Downloads/ninja-win.zip - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.NINJA}} - - name: Checkout CMake - if: steps.cmake.outputs.cache-hit != 'true' - shell: pwsh - run: Invoke-WebRequest ${env:CMAKE_URL} -OutFile ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip - - name: Checkout Ninja - if: steps.ninja.outputs.cache-hit != 'true' - shell: pwsh - run: Invoke-WebRequest ${env:NINJA_URL} -OutFile ~\Downloads\ninja-win.zip - - msvc: - needs: [tools] - runs-on: windows-2022 - strategy: - matrix: - VER: [v141, v142, v143] - EXT: [ON, OFF] - GEN: [Visual Studio 17 2022, Ninja Multi-Config] - BIN: [x64, x86] - STD: [90, 11, 17] - CMAKE: [3.22.0] - NINJA: [1.10.2] - env: - CMAKE_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\cmake.exe - CTEST_EXE: C:\Tools\Kitware\CMake\${{matrix.CMAKE}}\bin\ctest.exe - NINJA_EXE: C:\Tools\Ninja\ninja.exe - - steps: - - name: Checkout OpenCL-ICD-Loader - uses: actions/checkout@v3 - - - name: Checkout OpenCL-Headers - uses: actions/checkout@v3 - with: - repository: KhronosGroup/OpenCL-Headers - path: external/OpenCL-Headers - - - name: Restore CMake - uses: actions/cache@v3 - id: cmake - env: - cache-name: cache-cmake - with: - path: ~/Downloads/cmake-${{matrix.CMAKE}}-windows-x86_64.zip - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.CMAKE}} - - - name: Restore Ninja - uses: actions/cache@v3 - id: ninja - env: - cache-name: cache-ninja - with: - path: ~/Downloads/ninja-win.zip - key: ${{ runner.os }}-${{ env.cache-name }}-${{matrix.NINJA}} - - - name: Create Build Environment - shell: pwsh - run: | - Expand-Archive ~\Downloads\cmake-${{matrix.CMAKE}}-windows-x86_64.zip -DestinationPath C:\Tools\Kitware\CMake\ - Rename-Item C:\Tools\Kitware\CMake\* ${{matrix.CMAKE}} - Expand-Archive ~\Downloads\ninja-win.zip -DestinationPath C:\Tools\Ninja\ - & ${env:CMAKE_EXE} --version - & ${env:NINJA_EXE} --version - - - name: Build & install OpenCL-Headers (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - set C_FLAGS="/W4 /WX" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -D BUILD_TESTING=OFF -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install --config Release -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build & install OpenCL-Headers (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - set C_FLAGS="/W4 /WX" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -D BUILD_TESTING=OFF -S %GITHUB_WORKSPACE%\external\OpenCL-Headers -B %GITHUB_WORKSPACE%\external\OpenCL-Headers\build - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/external/OpenCL-Headers/build --target install -- -j%NUMBER_OF_PROCESSORS% - - - name: Configure (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -G "${{matrix.GEN}}" -A %BIN% -T ${{matrix.VER}} -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Configure (Ninja Multi-Config) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - # no /WX during configuration because: - # warning C4459: declaration of 'platform' hides global declaration - # warning C4100: 'input_headers': unreferenced formal parameter - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D BUILD_TESTING=ON -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH=%GITHUB_WORKSPACE%\external\OpenCL-Headers\install -S %GITHUB_WORKSPACE% -B %GITHUB_WORKSPACE%\build - - - name: Build (MSBuild) - if: matrix.GEN == 'Visual Studio 17 2022' - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release -- /verbosity:minimal /maxCpuCount /noLogo - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug -- /verbosity:minimal /maxCpuCount /noLogo - - - name: Build (Ninja) - if: matrix.GEN == 'Ninja Multi-Config' - shell: cmd - run: | - if /I "${{matrix.VER}}"=="v140" set VER=14.0 - if /I "${{matrix.VER}}"=="v141" set VER=14.1 - if /I "${{matrix.VER}}"=="v142" set VER=14.2 - if /I "${{matrix.VER}}"=="v143" set VER=14.3 - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%\build --config Debug - - - name: Test - working-directory: ${{runner.workspace}}/OpenCL-ICD-Loader/build - shell: cmd - run: | - if /I "${{matrix.BIN}}"=="x64" set REG=reg - if /I "${{matrix.BIN}}"=="x86" set REG=%systemroot%\Syswow64\reg.exe - %REG% ADD HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll /t REG_DWORD /d 0 - %CTEST_EXE% -C Release --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - if errorlevel 1 ( - exit /b %errorlevel% - ) - %REG% DELETE HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll /f - %REG% ADD HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Debug/OpenCLDriverStub.dll /t REG_DWORD /d 0 - %CTEST_EXE% -C Debug --output-on-failure --parallel %NUMBER_OF_PROCESSORS% - if errorlevel 1 ( - exit /b %errorlevel% - ) - %REG% DELETE HKEY_LOCAL_MACHINE\SOFTWARE\Khronos\OpenCL\Vendors /v %GITHUB_WORKSPACE%/build/Debug/OpenCLDriverStub.dll /f - - - name: Install - shell: cmd - run: | - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/build --config Release --target install - - - name: "Consume (MSBuild standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (MSBuild SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.BIN}}"=="x86" (set BIN=Win32) else (set BIN=x64) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config standalone): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsall.bat" ${{matrix.BIN}} /vcvars_ver=%VER% - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug - - - name: "Consume (Ninja-Multi-Config SDK): Configure/Build/Test" - shell: cmd - run: | - set C_FLAGS="/W4" - if /I "${{matrix.VER}}"=="v140" (set VER=14.0) - if /I "${{matrix.VER}}"=="v141" (set VER=14.1) - if /I "${{matrix.VER}}"=="v142" (set VER=14.2) - if /I "${{matrix.VER}}"=="v143" (set VER=14.3) - %CMAKE_EXE% -E make_directory $GITHUB_WORKSPACE/install/share/cmake/OpenCL - echo -e 'include("/home/runner/work/OpenCL-ICD-Loader/OpenCL-ICD-Loader/external/OpenCL-Headers/install/share/cmake/OpenCLHeaders/OpenCLHeadersTargets.cmake")\ninclude("${CMAKE_CURRENT_LIST_DIR}/../OpenCLICDLoader/OpenCLICDLoaderTargets.cmake")' > $GITHUB_WORKSPACE/install/share/cmake/OpenCL/OpenCLConfig.cmake - %CMAKE_EXE% -G "${{matrix.GEN}}" -D CMAKE_MAKE_PROGRAM=%NINJA_EXE% -D CMAKE_C_FLAGS=%C_FLAGS% -D CMAKE_C_STANDARD=${{matrix.STD}} -D CMAKE_C_EXTENSIONS=${{matrix.EXT}} -D CMAKE_EXE_LINKER_FLAGS=/INCREMENTAL -D CMAKE_INSTALL_PREFIX=%GITHUB_WORKSPACE%\install -D CMAKE_PREFIX_PATH="%GITHUB_WORKSPACE%\external\OpenCL-Headers\install;%GITHUB_WORKSPACE%\install" -D DRIVER_STUB_PATH=%GITHUB_WORKSPACE%/build/Release/OpenCLDriverStub.dll -B %GITHUB_WORKSPACE%/build/downstream/bare -S %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Release - %CMAKE_EXE% --build %GITHUB_WORKSPACE%/test/pkgconfig/bare --config Debug - cd %GITHUB_WORKSPACE%/test/pkgconfig/bare - %CTEST_EXE% --output-on-failure -C Release - %CTEST_EXE% --output-on-failure -C Debug From fb252dd3b0602db8b319e7e33c48c0577ed5e84c Mon Sep 17 00:00:00 2001 From: Sapna Date: Tue, 23 Jul 2024 03:07:57 +0530 Subject: [PATCH 5/5] Fix for static analysis issues Below are the issues fixed: - Argument cannot be negative - Time of check time of use Tracked-On: OAM-122163 Signed-off-by: Sapna --- loader/linux/icd_linux.c | 35 ++++++++++++++++++++++++++++------- 1 file changed, 28 insertions(+), 7 deletions(-) diff --git a/loader/linux/icd_linux.c b/loader/linux/icd_linux.c index 44915fe..7600384 100644 --- a/loader/linux/icd_linux.c +++ b/loader/linux/icd_linux.c @@ -28,6 +28,8 @@ #include #include #include +#include +#include static pthread_once_t initialized = PTHREAD_ONCE_INIT; @@ -44,6 +46,7 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char { struct stat statBuff; char* fileName = NULL; + int fd; // make sure the file name ends in `extension` (eg. .icd, or .lay) if (strlen(extension) > strlen(d_name)) @@ -64,9 +67,17 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char } sprintf(fileName, "%s/%s", path, d_name); - if (stat(fileName, &statBuff)) - { - KHR_ICD_TRACE("Failed stat for: %s, continuing\n", fileName); + fd = open(fileName, O_RDONLY); + if (fd == -1) { + KHR_ICD_TRACE("Opening Failed for File: %s\n", fileName); + free(fileName); + return; + } + + // Get file status information using fstat + if (fstat(fd, &statBuff) == -1) { + KHR_ICD_TRACE("Failed fstat for file: %s\n", fileName); + close(fd); free(fileName); return; } @@ -77,19 +88,26 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char char* buffer = NULL; long bufferSize = 0; - // open the file and read its contents - fin = fopen(fileName, "r"); - if (!fin) - { + fin = fdopen(fd, "r"); + if (!fin) { + close(fd); free(fileName); return; } fseek(fin, 0, SEEK_END); bufferSize = ftell(fin); + if (bufferSize == -1) { + close(fd); + free(fileName); + fclose(fin); + return; + } + buffer = malloc(bufferSize+1); if (!buffer) { + close(fd); free(fileName); fclose(fin); return; @@ -98,6 +116,7 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char fseek(fin, 0, SEEK_SET); if (bufferSize != (long)fread(buffer, 1, bufferSize, fin)) { + close(fd); free(fileName); free(buffer); fclose(fin); @@ -109,6 +128,7 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char // load the string read from the file addFunc(buffer); + close(fd); free(fileName); free(buffer); fclose(fin); @@ -116,6 +136,7 @@ static inline void khrIcdOsDirEntryValidateAndAdd(const char *d_name, const char else { KHR_ICD_TRACE("File %s is not a regular file nor symbolic link, continuing\n", fileName); + close(fd); free(fileName); } }