From 6c113ed1a95a08d17c2d556bd7b03c901512a34f Mon Sep 17 00:00:00 2001 From: Gian Marco Iodice Date: Thu, 19 Jan 2023 17:14:26 +0000 Subject: Prepare the basic types for the compute kernel writer (CKW) - Add TensorInfo - Add TileInfo - Add CLTile - Add basic utility methods to get tensor components - Add unit tests Resolves COMPMID-5782, COMPMID-5785 Signed-off-by: Gian Marco Iodice Change-Id: I5e590bddd240d2f1fc876cac7129947558d7d53b Reviewed-on: https://eu-gerrit-1.euhpc.arm.com/c/VisualCompute/ComputeLibrary/+/486221 Tested-by: bsgcomp Reviewed-by: Jakub Sujak Reviewed-by: Pablo Tello Comments-Addressed: bsgcomp Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/9687 Reviewed-by: Viet-Hoa Do Reviewed-by: Pablo Marquez Tello Comments-Addressed: Arm Jenkins Tested-by: Arm Jenkins Benchmark: Arm Jenkins --- compute_kernel_writer/SConscript | 81 ++++++ compute_kernel_writer/SConstruct | 254 +++++++++++++++++ compute_kernel_writer/include/ckw/Error.h | 59 ++++ compute_kernel_writer/include/ckw/TensorInfo.h | 135 +++++++++ compute_kernel_writer/include/ckw/TileInfo.h | 84 ++++++ compute_kernel_writer/include/ckw/Types.h | 45 +++ compute_kernel_writer/src/Error.cpp | 40 +++ compute_kernel_writer/src/Helpers.cpp | 63 +++++ compute_kernel_writer/src/Helpers.h | 56 ++++ compute_kernel_writer/src/ITile.h | 134 +++++++++ compute_kernel_writer/src/TensorInfo.cpp | 77 +++++ compute_kernel_writer/src/TensorUtils.cpp | 116 ++++++++ compute_kernel_writer/src/TensorUtils.h | 56 ++++ compute_kernel_writer/src/TileInfo.cpp | 76 +++++ compute_kernel_writer/src/cl/CLHelpers.cpp | 91 ++++++ compute_kernel_writer/src/cl/CLHelpers.h | 53 ++++ compute_kernel_writer/src/cl/CLTile.cpp | 156 +++++++++++ compute_kernel_writer/src/cl/CLTile.h | 61 ++++ compute_kernel_writer/validation/SConscript | 100 +++++++ compute_kernel_writer/validation/Validation.cpp | 76 +++++ .../validation/tests/CLTileTest.hpp | 311 +++++++++++++++++++++ .../validation/tests/TensorBitMaskTest.hpp | 217 ++++++++++++++ .../validation/tests/UtilsTest.hpp | 102 +++++++ .../validation/tests/common/Common.h | 69 +++++ scripts/clang_tidy_rules.py | 3 + 25 files changed, 2515 insertions(+) create mode 100644 compute_kernel_writer/SConscript create mode 100644 compute_kernel_writer/SConstruct create mode 100644 compute_kernel_writer/include/ckw/Error.h create mode 100644 compute_kernel_writer/include/ckw/TensorInfo.h create mode 100644 compute_kernel_writer/include/ckw/TileInfo.h create mode 100644 compute_kernel_writer/include/ckw/Types.h create mode 100644 compute_kernel_writer/src/Error.cpp create mode 100644 compute_kernel_writer/src/Helpers.cpp create mode 100644 compute_kernel_writer/src/Helpers.h create mode 100644 compute_kernel_writer/src/ITile.h create mode 100644 compute_kernel_writer/src/TensorInfo.cpp create mode 100644 compute_kernel_writer/src/TensorUtils.cpp create mode 100644 compute_kernel_writer/src/TensorUtils.h create mode 100644 compute_kernel_writer/src/TileInfo.cpp create mode 100644 compute_kernel_writer/src/cl/CLHelpers.cpp create mode 100644 compute_kernel_writer/src/cl/CLHelpers.h create mode 100644 compute_kernel_writer/src/cl/CLTile.cpp create mode 100644 compute_kernel_writer/src/cl/CLTile.h create mode 100644 compute_kernel_writer/validation/SConscript create mode 100644 compute_kernel_writer/validation/Validation.cpp create mode 100644 compute_kernel_writer/validation/tests/CLTileTest.hpp create mode 100644 compute_kernel_writer/validation/tests/TensorBitMaskTest.hpp create mode 100644 compute_kernel_writer/validation/tests/UtilsTest.hpp create mode 100644 compute_kernel_writer/validation/tests/common/Common.h diff --git a/compute_kernel_writer/SConscript b/compute_kernel_writer/SConscript new file mode 100644 index 0000000000..8fc2b11dec --- /dev/null +++ b/compute_kernel_writer/SConscript @@ -0,0 +1,81 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# Copyright (c) 2023 Arm Limited. +# +# SPDX-License-Identifier: MIT +# +# 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.path + +LIB_PREFIX = "ckw" # Compute Kernel Writer (CKW) +VERSION = "v0.0-unreleased" +LIBRARY_VERSION_MAJOR = 1 +LIBRARY_VERSION_MINOR = 0 +LIBRARY_VERSION_PATCH = 0 +SONAME_VERSION = str(LIBRARY_VERSION_MAJOR) + "." + str(LIBRARY_VERSION_MINOR) + "." + str(LIBRARY_VERSION_PATCH) + +Import('env') +Import('vars') +Import('install_lib') + +def build_library(name, build_env, sources, static=False, libs=[]): + cloned_build_env = build_env.Clone() + if env['os'] == 'android' and static == False: + cloned_build_env["LINKFLAGS"].remove('-pie') + cloned_build_env["LINKFLAGS"].remove('-static-libstdc++') + + if static: + obj = cloned_build_env.StaticLibrary(name, source=sources, LIBS = ckw_env["LIBS"] + libs) + else: + obj = cloned_build_env.SharedLibrary(name, source=sources, LIBS = ckw_env["LIBS"] + libs) + + obj = install_lib(obj) + build_env.Default(obj) + return obj + +ckw_env = env.Clone() + +default_cpp_compiler = 'g++' if env['os'] not in ['android'] else 'clang++' +cpp_compiler = os.environ.get('CXX', default_cpp_compiler) + +ckw_env.Append(CPPPATH =[Dir("./src/").path] ) + +# Append version defines for semantic versioning +ckw_env.Append(CPPDEFINES = [('COMPUTE_KERNEL_WRITER_VERSION_MAJOR', LIBRARY_VERSION_MAJOR), + ('COMPUTE_KERNEL_WRITER_VERSION_MINOR', LIBRARY_VERSION_MINOR), + ('COMPUTE_KERNEL_WRITER_VERSION_PATCH', LIBRARY_VERSION_PATCH)]) + +# Don't allow undefined references in the libraries: +undefined_flag = '-Wl,--no-undefined' +ckw_env.Append(LINKFLAGS=[undefined_flag]) + +# Kernel writer files +kernel_writer_files = Glob('./src/*.cpp') + +# OpenCL specific files +kernel_writer_files += Glob('./src/cl/*.cpp') + +ckw_a = build_library(LIB_PREFIX + '-static', ckw_env, kernel_writer_files, static=True) +Export('ckw_a') + +# SHARED library build. +ckw_so = build_library(LIB_PREFIX, ckw_env, kernel_writer_files, static=False) +Export('ckw_so') \ No newline at end of file diff --git a/compute_kernel_writer/SConstruct b/compute_kernel_writer/SConstruct new file mode 100644 index 0000000000..a67522fedd --- /dev/null +++ b/compute_kernel_writer/SConstruct @@ -0,0 +1,254 @@ +# -*- coding: utf-8 -*- + +# Copyright (c) 2023 Arm Limited. +# +# SPDX-License-Identifier: MIT +# +# 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 SCons +import os +from subprocess import check_output + +def version_at_least(version, required): + + version_list = version.split('.') + required_list = required.split('.') + end = min(len(version_list), len(required_list)) + for i in range(0, end): + if int(version_list[i]) < int(required_list[i]): + return False + elif int(version_list[i]) > int(required_list[i]): + return True + + return True + +vars = Variables("scons") +vars.AddVariables( + BoolVariable("debug", "Debug", False), + BoolVariable("asserts", "Enable asserts (this flag is forced to 1 for debug=1)", False), + EnumVariable("arch", "Target Architecture.", "armv8.2-a", + allowed_values=("x86_64", "armv8.2-a")), + EnumVariable("os", "Target OS.", "linux", allowed_values=("linux", "android")), + EnumVariable("build", "Either build directly on your device (native) or cross compile from your desktop machine (cross-compile). In both cases make sure the compiler is available in your path.", "cross_compile", allowed_values=("native", "cross_compile", "embed_only")), + BoolVariable("Werror", "Enable/disable the -Werror compilation flag", True), + PathVariable("build_dir", "Specify sub-folder for the build", ".", PathVariable.PathAccept), + PathVariable("install_dir", "Specify sub-folder for the install", "", PathVariable.PathAccept), + BoolVariable("exceptions", "Enable/disable C++ exception support", True), + PathVariable("linker_script", "Use an external linker script", "", PathVariable.PathAccept), + ("toolchain_prefix", "Override the toolchain prefix; used by all toolchain components: compilers, linker, assembler etc. If unspecified, use default(auto) prefixes; if passed an empty string '' prefixes would be disabled", "auto"), + ("compiler_prefix", "Override the compiler prefix; used by just compilers (CC,CXX); further overrides toolchain_prefix for compilers; this is for when the compiler prefixes are different from that of the linkers, archivers etc. If unspecified, this is the same as toolchain_prefix; if passed an empty string '' prefixes would be disabled", "auto"), + ("extra_cxx_flags", "Extra CXX flags to be appended to the build command", ""), + ("extra_link_flags", "Extra LD flags to be appended to the build command", ""), + ("compiler_cache", "Command to prefix to the C and C++ compiler (e.g ccache)", ""), + ("specs_file", "Specs file to use (e.g. rdimon.specs)", "") +) + +if version_at_least(SCons.__version__, "4.0"): + vars.Add(BoolVariable("export_compile_commands", "Export compile_commands.json file.", False)) + +env = Environment(variables=vars, ENV = os.environ) + +build_path = env['build_dir'] +# If build_dir is a relative path then add a #build/ prefix: +if not env['build_dir'].startswith('/'): + SConsignFile('build/%s/.scons' % build_path) + build_path = "#build/%s" % build_path +else: + SConsignFile('%s/.scons' % build_path) + +install_path = env['install_dir'] +#If the install_dir is a relative path then assume it's from inside build_dir +if not env['install_dir'].startswith('/') and install_path != "": + install_path = "%s/%s" % (build_path, install_path) + +env.Append(LIBPATH = [build_path]) +Export('env') +Export('vars') + +def install_lib( lib ): + # If there is no install folder, then there is nothing to do: + if install_path == "": + return lib + return env.Install( "%s/lib/" % install_path, lib) +def install_bin( bin ): + # If there is no install folder, then there is nothing to do: + if install_path == "": + return bin + return env.Install( "%s/bin/" % install_path, bin) +def install_include( inc ): + if install_path == "": + return inc + return env.Install( "%s/include/" % install_path, inc) + +Export('install_lib') +Export('install_bin') + +Help(vars.GenerateHelpText(env)) + +env.Append(CXXFLAGS = [ + '-Wextra','-Wdisabled-optimization','-Wformat=2', + '-Winit-self','-Wstrict-overflow=2','-Wswitch-default', + '-Woverloaded-virtual', '-Wformat-security', + '-Wctor-dtor-privacy','-Wsign-promo','-Weffc++','-Wno-overlength-strings']) + +env.Append(CXXFLAGS = ['-Wall','-std=c++14', '-pedantic' ]) + +env.Append(CPPDEFINES = ['_GLIBCXX_USE_NANOSLEEP']) + +cpp_tool = {'linux': 'g++', 'android' : 'clang++'} + +c_tool = {'linux':'gcc', 'android': 'clang'} + +default_cpp_compiler = cpp_tool[env['os']] +default_c_compiler = c_tool[env['os']] +cpp_compiler = os.environ.get('CXX', default_cpp_compiler) +c_compiler = os.environ.get('CC', default_c_compiler) + +if env['os'] == 'android' and ( 'clang++' not in cpp_compiler or 'clang' not in c_compiler ): + print( "WARNING: Only clang is officially supported to build the Compute Kernel Writer (CKW) for Android") + +if 'clang++' in cpp_compiler: + env.Append(CXXFLAGS = ['-Wno-vla-extension']) +elif 'armclang' in cpp_compiler: + pass +else: + env.Append(CXXFLAGS = ['-Wlogical-op','-Wnoexcept','-Wstrict-null-sentinel','-Wno-misleading-indentation']) + +if cpp_compiler == 'g++': + # Don't strip comments that could include markers + env.Append(CXXFLAGS = ['-C']) + +if 'armv8-a' in env['arch']: + env.Append(CXXFLAGS = ['-march=armv8-a']) + +if 'x86_64' in env['arch']: + env.Append(CXXFLAGS = ['-fPIC']) + env.Append(CCFLAGS = ['-m64']) + env.Append(LINKFLAGS = ['-m64']) + +# Define toolchain +# The reason why we distinguish toolchain_prefix from compiler_prefix is for cases where the linkers/archivers use a +# different prefix than the compilers. An example is the NDK r20 toolchain +auto_toolchain_prefix = "" +if 'x86' not in env['arch']: + if env['os'] == 'linux': + auto_toolchain_prefix = "aarch64-linux-gnu-" + elif env['os'] == 'android': + auto_toolchain_prefix = "aarch64-tizen-linux-gnu-" + +if env['build'] == 'native' or env["toolchain_prefix"] == "": + toolchain_prefix = "" +elif env["toolchain_prefix"] == "auto": + toolchain_prefix = auto_toolchain_prefix +else: + toolchain_prefix = env["toolchain_prefix"] + +if env['build'] == 'native' or env["compiler_prefix"] == "": + compiler_prefix = "" +elif env["compiler_prefix"] == "auto": + compiler_prefix = toolchain_prefix +else: + compiler_prefix = env["compiler_prefix"] + +env['CC'] = env['compiler_cache']+ " " + compiler_prefix + c_compiler +env['CXX'] = env['compiler_cache']+ " " + compiler_prefix + cpp_compiler +env['LD'] = toolchain_prefix + "ld" +env['AS'] = toolchain_prefix + "as" +env['AR'] = toolchain_prefix + "ar" +env['RANLIB'] = toolchain_prefix + "ranlib" + +print("Using compilers:") +print("CC", env['CC']) +print("CXX", env['CXX']) + +if not GetOption("help"): + try: + compiler_ver = check_output(env['CXX'].split() + ["-dumpversion"]).decode().strip() + except OSError: + print("ERROR: Compiler '%s' not found" % env['CXX']) + Exit(1) + + if 'armclang' in cpp_compiler: + pass + elif 'clang++' not in cpp_compiler: + if env['arch'] == 'arm64-v8.2-a' and not version_at_least(compiler_ver, '6.2.1'): + print("GCC 6.2.1 or newer is required to compile armv8.2-a code") + Exit(1) + + if version_at_least(compiler_ver, '6.1'): + env.Append(CXXFLAGS = ['-Wno-ignored-attributes']) + + if compiler_ver == '4.8.3': + env.Append(CXXFLAGS = ['-Wno-array-bounds']) + + # Add Android NDK toolchain specific flags + if 'clang++' in cpp_compiler and env['os'] == 'android': + # For NDK >= r21, clang 9 or above is used + if version_at_least(compiler_ver, '9.0.0'): + env['ndk_above_r21'] = True + + # For NDK >= r23, clang 12 or above is used. This condition detects NDK < r23 + if not version_at_least(compiler_ver, '12.0.0'): + # System assembler is deprecated and integrated assembler is preferred since r23. + # However integrated assembler has always been suppressed for NDK < r23. + # Thus for backward compatibility, we include this flag only for NDK < r23 + env.Append(CXXFLAGS = ['-no-integrated-as']) + +if env['Werror']: + env.Append(CXXFLAGS = ['-Werror']) + +if env['os'] == 'android': + env.Append(CPPDEFINES = ['ANDROID']) + env.Append(LINKFLAGS = ['-pie', '-static-libstdc++', '-ldl']) + +if env['specs_file'] != "": + env.Append(LINKFLAGS = ['-specs='+env['specs_file']]) + +if env['debug']: + env['asserts'] = True + env.Append(CXXFLAGS = ['-O0','-g','-gdwarf-2']) + env.Append(CPPDEFINES = ['COMPUTE_KERNEL_WRITER_DEBUG_ENABLED']) +else: + # Optimize for size + env.Append(CXXFLAGS = ['-Os']) + +if env['asserts']: + env.Append(CPPDEFINES = ['COMPUTE_KERNEL_WRITER_ASSERTS_ENABLED']) + env.Append(CXXFLAGS = ['-fstack-protector-strong']) + +env.Append(CPPPATH = ['#/include', "#"]) +env.Append(CXXFLAGS = env['extra_cxx_flags']) +env.Append(LINKFLAGS = env['extra_link_flags']) +env.Append(LIBS = []) + +Export('version_at_least') + +SConscript('./SConscript', variant_dir=build_path, duplicate=0) + +# Tests +SConscript('./validation/SConscript', variant_dir='%s/validation' % build_path, duplicate=0) + +# Unknown variables are not allowed +# Note: we must delay the call of UnknownVariables until after +# we have applied the Variables object to the construction environment +unknown = vars.UnknownVariables() +if unknown: + print("Unknown variables: %s" % " ".join(unknown.keys())) + Exit(1) diff --git a/compute_kernel_writer/include/ckw/Error.h b/compute_kernel_writer/include/ckw/Error.h new file mode 100644 index 0000000000..996893823e --- /dev/null +++ b/compute_kernel_writer/include/ckw/Error.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_INCLUDE_CKW_ERROR_H +#define COMPUTE_KERNEL_WRITER_INCLUDE_CKW_ERROR_H + +#include +#include + +namespace ckw +{ +/** Creates the error message + * + * @param[in] file File in which the error occurred. + * @param[in] func Function in which the error occurred. + * @param[in] line Line in which the error occurred. + * @param[in] msg Message to display before abandoning. + * + * @return status containing the error + */ +std::string create_error_msg(const std::string &file, const std::string &func, const std::string &line, const std::string &msg); + +/** Print the given message then throw an std::runtime_error. + * + * @param[in] msg Message to display. + */ +#define COMPUTE_KERNEL_WRITER_ERROR_ON_MSG(msg) \ + do \ + { \ + const std::string arg0(__FILE__); \ + const std::string arg1(__func__); \ + const std::string arg2(std::to_string(__LINE__)); \ + const std::string arg3(msg); \ + std::runtime_error(create_error_msg(arg0, arg1, arg2, arg3)); \ + } while(false) + +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_INCLUDE_CKW_ERROR_H */ diff --git a/compute_kernel_writer/include/ckw/TensorInfo.h b/compute_kernel_writer/include/ckw/TensorInfo.h new file mode 100644 index 0000000000..b5f76cffa5 --- /dev/null +++ b/compute_kernel_writer/include/ckw/TensorInfo.h @@ -0,0 +1,135 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#ifndef COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TENSORINFO_H +#define COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TENSORINFO_H + +#include "ckw/Types.h" + +#include +#include + +namespace ckw +{ +/** Compute Kernel Writer tensor data layout (or memory format) */ +enum class TensorDataLayout +{ + Unknown, + Nhwc, + Ndhwc +}; + +/** Compute Kernel Writer tensor data layout component */ +enum class TensorDataLayoutComponent +{ + Unknown, + N, + D, + H, + W, + C, +}; + +/** Compute Kernel Writer tensor component bitmask. The bitmask can be used to retrieve + * the info from @ref TensorComponent. + */ +enum class TensorComponentBitmask : uint32_t +{ + OffsetFirstElement = 0x01000000, // For example, OffsetFirstElement in @ref TensorComponent + Stride = 0x02000000, // For example, stride0 in @ref TensorComponent + Dimension = 0x04000000, // For example, Dim0 in @ref TensorComponent + FoldedDimensions = 0x08000000, // For example, Dim0xDim1 in @ref TensorComponent +}; + +/** Compute Kernel Writer tensor component. The tensor components are used to access specific backend-agnostic tensor arguments, + * such as the tensor dimensions and tensor strides. + * The data type is represented as an integer. The value of the integer value + * is assigned to retrieve the information through the @ref TensorComponentBitmask. + */ +enum class TensorComponent : uint32_t +{ + Unknown = 0x00000000, + OffsetFirstElement = 0x01000000, + Stride0 = 0x02000001, + Stride1 = 0x02000010, + Stride2 = 0x02000100, + Stride3 = 0x02001000, + Stride4 = 0x02010000, + Dim0 = 0x04000001, + Dim1 = 0x04000010, + Dim2 = 0x04000100, + Dim3 = 0x04001000, + Dim4 = 0x04010000, + Dim1xDim2 = 0x08000110, + Dim2xDim3 = 0x08001100, + Dim1xDim2xDim3 = 0x08001110 +}; + +/** Compute Kernel Writer tensor shape + * Negative dimensions can be interpreted as dynamic dimensions by the Compute Kernel Writer + */ +using TensorShape = std::array; + +/** Compute Kernel Writer tensor info */ +class TensorInfo +{ +public: + /** Constructor + * + * @param[in] dt Tensor data type + * @param[in] shape Tensor shape + * @param[in] dl Tensor data layout + * @param[in] id Tensor id. The id is used to keep track of the user tensor binded. Through the id, + * the user can know what tensor has been used by the Compute Kernel Writer. + * Possible id values: + * - greater than or equal to 0: bind a user specific tensors + * - less than 0: bind a virtual tensor (tile) + */ + TensorInfo(DataType dt, const TensorShape &shape, TensorDataLayout dl, int32_t id); + /** Set shape */ + TensorInfo &shape(const TensorShape &shape); + /** Get shape */ + TensorShape shape() const; + /** Set data type */ + TensorInfo &data_type(DataType dt); + /** Get data type */ + DataType data_type() const; + /** Set data layout */ + TensorInfo &data_layout(TensorDataLayout dl); + /** Get data layout */ + TensorDataLayout data_layout() const; + /** Set id */ + TensorInfo &id(int32_t id); + /** Get layout */ + int32_t id() const; + +private: + TensorShape _shape{ { 0 } }; + DataType _dt{ DataType::Unknown }; + TensorDataLayout _dl{ TensorDataLayout::Unknown }; + int32_t _id{ -1 }; +}; +} // namespace kw + +#endif /* COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TENSORINFO_H */ diff --git a/compute_kernel_writer/include/ckw/TileInfo.h b/compute_kernel_writer/include/ckw/TileInfo.h new file mode 100644 index 0000000000..4f801513b0 --- /dev/null +++ b/compute_kernel_writer/include/ckw/TileInfo.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#ifndef COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TILEINFO_H +#define COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TILEINFO_H + +#include "ckw/Types.h" + +#include +#include + +namespace ckw +{ +// Constants to access the tile width and height in the TileShape +constexpr int32_t kTileWidthIdx = 0; +constexpr int32_t kTileHeightIdx = 1; + +/** Compute Kernel Writer tile shape */ +using TileShape = std::array; + +/** Compute Kernel Writer tile info */ +class TileInfo +{ +public: + /** Constructor used to initialize a scalar variable with a given data type + * + * @param[in] dt Tile data type + */ + TileInfo(DataType dt); + /** Constructor used to initialize a vector with a given data type and vector length. + * + * @param[in] dt Tile data type + * @param[in] w Tile width (or vector length) + */ + TileInfo(DataType dt, int32_t w); + /** Constructor used to initialize a tile with a given data type and tile sizes. + * + * @param[in] dt Tile data type + * @param[in] w Tile width + * @param[in] h Tile height + */ + TileInfo(DataType dt, int32_t w, int32_t h); + /** Set width */ + TileInfo &width(int32_t w); + /** Get width */ + int32_t width() const; + /** Set height */ + TileInfo &height(int32_t h); + /** Get height */ + int32_t height() const; + /** Set data type */ + TileInfo &data_type(DataType dt); + /** Get data type */ + DataType data_type() const; + +private: + DataType _dt{ DataType::Unknown }; + TileShape _shape{}; +}; + +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TILEINFO_H */ diff --git a/compute_kernel_writer/include/ckw/Types.h b/compute_kernel_writer/include/ckw/Types.h new file mode 100644 index 0000000000..c9f80b65e0 --- /dev/null +++ b/compute_kernel_writer/include/ckw/Types.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TYPES_H +#define COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TYPES_H + +namespace ckw +{ +/** Compute Kernel Writer data types. This data type is used by the code variables and tensor arguments. */ +enum class DataType +{ + Unknown, + Fp32, + Fp16, + Int32, + Int16, + Int8, + Uint32, + Uint16, + Uint8, + Bool +}; +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_INCLUDE_CKW_TYPES_H */ diff --git a/compute_kernel_writer/src/Error.cpp b/compute_kernel_writer/src/Error.cpp new file mode 100644 index 0000000000..7f2fb41187 --- /dev/null +++ b/compute_kernel_writer/src/Error.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "ckw/Error.h" + +#include + +namespace ckw +{ +std::string create_error_msg(const std::string &file, const std::string &func, const std::string &line, const std::string &msg) +{ + std::string err; + err += "[COMPUTE_KERNEL_WRITER][ERROR]:"; + err += " " + file + ":" + line; + err += " " + func; + err += " " + msg; + return err; +} +} // namespace ckw \ No newline at end of file diff --git a/compute_kernel_writer/src/Helpers.cpp b/compute_kernel_writer/src/Helpers.cpp new file mode 100644 index 0000000000..799f79a187 --- /dev/null +++ b/compute_kernel_writer/src/Helpers.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "ckw/Error.h" + +#include "src/Helpers.h" + +namespace ckw +{ +std::string dec_to_hex_as_string(int32_t dec) +{ + switch(dec) + { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + case 8: + case 9: + return std::to_string(dec); + case 10: + return "A"; + case 11: + return "B"; + case 12: + return "C"; + case 13: + return "D"; + case 14: + return "E"; + case 15: + return "F"; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported decimal number"); + return ""; + } +} +} // namespace ckw diff --git a/compute_kernel_writer/src/Helpers.h b/compute_kernel_writer/src/Helpers.h new file mode 100644 index 0000000000..f7ba7cec1c --- /dev/null +++ b/compute_kernel_writer/src/Helpers.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#ifndef COMPUTE_KERNEL_WRITER_SRC_HELPERS_H +#define COMPUTE_KERNEL_WRITER_SRC_HELPERS_H + +#include +#include + +/** Generic helper functions */ +namespace ckw +{ +/** Helper function to convert a decimal number passed as int32_t variable to hexadecimal number as string + * + * @param[in] dec Decimal number. It must be >= 0 and < 16 + * + * @return the OpenCL datatype as a string + */ +std::string dec_to_hex_as_string(int32_t dec); + +/** Helper function to clamp a value between min_val and max_val + * + * @param[in] val Value to clamp + * @param[in] min_val Lower value + * @param[in] max_val Upper value + * + * @return the clamped value + */ +template +T clamp(const T& val, const T& min_val, const T& max_val) +{ + return std::max(min_val, std::min(val, max_val)); +} +} +#endif /* COMPUTE_KERNEL_WRITER_SRC_HELPERS_H */ diff --git a/compute_kernel_writer/src/ITile.h b/compute_kernel_writer/src/ITile.h new file mode 100644 index 0000000000..283e6fa236 --- /dev/null +++ b/compute_kernel_writer/src/ITile.h @@ -0,0 +1,134 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_SRC_ITILE_H +#define COMPUTE_KERNEL_WRITER_SRC_ITILE_H + +#include "ckw/TileInfo.h" + +#include +#include + +namespace ckw +{ +/** Tile descriptor which reports the underlying datatype and vector length */ +struct TileVariableDescriptor +{ + DataType dt { DataType::Unknown }; /** Data type */ + int32_t len { 1 }; /** Number of elements in a single variable. For example, 1 for scalar */ +}; + +/** Tile variable */ +struct TileVariable +{ + std::string str {""}; /** Tile variable as a string */ + TileVariableDescriptor desc {}; /** Tile value descriptor which reports the datatype and vector length */ +}; + +/** Tile base class. + * A Tile is a collection of variables (either program variables or constants) used to express a 2D data. + */ +class ITile +{ +public: + virtual ~ITile() = default; + /** Method to get all TileVariable objects + * + * @return a vector containing all @ref TileVariable objects + */ + virtual std::vector all() const = 0; + /** Method to get the name of the tile. + * + * @return the name of the tile + */ + std::string name() const + { + return _basename; + } + /** Method to get the tile info + * + * @return the @ref TileInfo + */ + TileInfo info() const + { + return _info; + } + /** Method to know whether the tile is assignable or not. + * For example, a constant tile is not assignable. + * + * @return true if the tile is assignable + */ + virtual bool is_assignable() const = 0; + +protected: + TileInfo _info { DataType::Unknown }; // Tile info + std::string _basename { "" }; // Tile name +}; + +/** Tile base class to store scalar variables. + */ +class IScalarTile : public ITile +{ +public: + virtual ~IScalarTile() = default; + /** Method to get the scalar variable from a tile as a string + * @param[in] col Tile column. If out-of-bound, the column is clamped to the nearest valid edge + * @param[in] row Tile row. If out-of-bound, the row is clamped to the nearest valid edge + * + * @return the @ref TileVariable + */ + virtual TileVariable scalar(int32_t col, int32_t row) const = 0; +}; + +/** Tile base class to store vector variables. It derives from IScalarTile since we can still access the scalar variable + */ +class IVectorTile : public IScalarTile +{ +public: + virtual ~IVectorTile() = default; + /** Method to get the vector variable from a tile. + * The user can query the list of supported vector lengths through the supported_vector_lengths() method. + * + * @param[in] row Tile row. If out-of-bound, the row is clamped to the nearest valid edge + * + * @return the vector variable as a @ref TileVariable + */ + virtual TileVariable vector(int32_t row) const = 0; + /** Method to get a sub-vector variable. The length of the sub-vector must be supported by the derived IVectorTile class + * + * @param[in] col_start Tile starting column to get the sub-vector. If out-of-bound, the derived IVectorTile class may throw an assert. + * @param[in] width The width of the sub-vector. The width must be supported by the derived IVectorTile class and the last element must be in-bound. + * @param[in] row Tile row. If out-of-bound, the row is clamped to the nearest valid edge + * + * @return the vector variable as a @ref TileVariable + */ + virtual TileVariable vector(int32_t col_start, int32_t width, int32_t row) const = 0; + /** Method to get the supported vector length. + * + * @return a vector containing the supported vector lengths + */ + virtual std::vector supported_vector_lengths() const = 0; +}; +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_SRC_ITILE_H */ diff --git a/compute_kernel_writer/src/TensorInfo.cpp b/compute_kernel_writer/src/TensorInfo.cpp new file mode 100644 index 0000000000..561c126469 --- /dev/null +++ b/compute_kernel_writer/src/TensorInfo.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "ckw/TensorInfo.h" + +namespace ckw +{ +TensorInfo::TensorInfo(DataType dt, const TensorShape &shape, TensorDataLayout dl, int32_t id) + : _shape(shape), _dt(dt), _dl(dl), _id(id) +{ +} + +TensorInfo &TensorInfo::shape(const TensorShape &shape) +{ + _shape = shape; + return *this; +} + +TensorShape TensorInfo::shape() const +{ + return _shape; +} + +TensorInfo &TensorInfo::data_type(DataType dt) +{ + _dt = dt; + return *this; +} + +DataType TensorInfo::data_type() const +{ + return _dt; +} + +TensorInfo &TensorInfo::data_layout(TensorDataLayout dl) +{ + _dl = dl; + return *this; +} + +TensorDataLayout TensorInfo::data_layout() const +{ + return _dl; +} + +TensorInfo &TensorInfo::id(int32_t id) +{ + _id = id; + return *this; +} + +int32_t TensorInfo::id() const +{ + return _id; +} +} // namespace ckw diff --git a/compute_kernel_writer/src/TensorUtils.cpp b/compute_kernel_writer/src/TensorUtils.cpp new file mode 100644 index 0000000000..cc179b4b51 --- /dev/null +++ b/compute_kernel_writer/src/TensorUtils.cpp @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "ckw/Error.h" +#include "ckw/TensorInfo.h" +#include "ckw/Types.h" + +#include "src/TensorUtils.h" + +namespace ckw +{ +TensorComponent get_tensor_dimension(TensorDataLayout layout, TensorDataLayoutComponent component) +{ + switch(layout) + { + case TensorDataLayout::Nhwc: + switch(component) + { + case TensorDataLayoutComponent::C: + return TensorComponent::Dim0; + case TensorDataLayoutComponent::W: + return TensorComponent::Dim1; + case TensorDataLayoutComponent::H: + return TensorComponent::Dim2; + case TensorDataLayoutComponent::N: + return TensorComponent::Dim3; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor component for NHWC"); + return TensorComponent::Unknown; + } + case TensorDataLayout::Ndhwc: + switch(component) + { + case TensorDataLayoutComponent::C: + return TensorComponent::Dim0; + case TensorDataLayoutComponent::W: + return TensorComponent::Dim1; + case TensorDataLayoutComponent::H: + return TensorComponent::Dim2; + case TensorDataLayoutComponent::D: + return TensorComponent::Dim3; + case TensorDataLayoutComponent::N: + return TensorComponent::Dim4; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor component for NDHWC"); + return TensorComponent::Unknown; + } + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor data layout"); + return TensorComponent::Unknown; + } +} + +TensorComponent get_tensor_stride(TensorDataLayout layout, TensorDataLayoutComponent component) +{ + switch(layout) + { + case TensorDataLayout::Nhwc: + switch(component) + { + case TensorDataLayoutComponent::C: + return TensorComponent::Stride0; + case TensorDataLayoutComponent::W: + return TensorComponent::Stride1; + case TensorDataLayoutComponent::H: + return TensorComponent::Stride2; + case TensorDataLayoutComponent::N: + return TensorComponent::Stride3; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor component for NHWC"); + return TensorComponent::Unknown; + } + case TensorDataLayout::Ndhwc: + switch(component) + { + case TensorDataLayoutComponent::C: + return TensorComponent::Stride0; + case TensorDataLayoutComponent::W: + return TensorComponent::Stride1; + case TensorDataLayoutComponent::H: + return TensorComponent::Stride2; + case TensorDataLayoutComponent::D: + return TensorComponent::Stride3; + case TensorDataLayoutComponent::N: + return TensorComponent::Stride4; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor component for NDHWC"); + return TensorComponent::Unknown; + } + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported tensor data layout"); + return TensorComponent::Unknown; + } +} +} // namespace ckw diff --git a/compute_kernel_writer/src/TensorUtils.h b/compute_kernel_writer/src/TensorUtils.h new file mode 100644 index 0000000000..4be0395435 --- /dev/null +++ b/compute_kernel_writer/src/TensorUtils.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#ifndef COMPUTE_KERNEL_WRITER_SRC_TENSORUTILS_H +#define COMPUTE_KERNEL_WRITER_SRC_TENSORUTILS_H + +#include + +/** Tensor specific utility functions */ +namespace ckw +{ +// Forward declarations +enum class TensorDataLayout; +enum class TensorDataLayoutComponent; +enum class TensorComponent : uint32_t; + +/** Get tensor dimension from a given data layout and data layout component + * + * @param[in] layout Layout of the tensor + * @param[in] component Data layout component + * + * @return the @ref TensorComponent + */ +TensorComponent get_tensor_dimension(TensorDataLayout layout, TensorDataLayoutComponent component); + +/** Get tensor stride from a given data layout and data layout component + * + * @param[in] layout Layout of the tensor + * @param[in] component Data layout component + * + * @return the @ref TensorComponent + */ +TensorComponent get_tensor_stride(TensorDataLayout layout, TensorDataLayoutComponent component); +} +#endif /* COMPUTE_KERNEL_WRITER_SRC_TENSORUTILS_H */ diff --git a/compute_kernel_writer/src/TileInfo.cpp b/compute_kernel_writer/src/TileInfo.cpp new file mode 100644 index 0000000000..6dd1957a7a --- /dev/null +++ b/compute_kernel_writer/src/TileInfo.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "ckw/TileInfo.h" + +namespace ckw +{ +TileInfo::TileInfo(DataType dt) + : _dt(dt), _shape({{1, 1}}) +{ +} + +TileInfo::TileInfo(DataType dt, int32_t w) + : _dt(dt), _shape({{w, 1}}) +{ +} + +TileInfo::TileInfo(DataType dt, int32_t w, int32_t h) + : _dt(dt), _shape({{w, h}}) +{ +} + +TileInfo &TileInfo::width(int32_t w) +{ + _shape[kTileWidthIdx] = w; + return *this; +} + +int32_t TileInfo::width() const +{ + return _shape[kTileWidthIdx]; +} + +TileInfo &TileInfo::height(int32_t h) +{ + _shape[kTileHeightIdx] = h; + return *this; +} + +int32_t TileInfo::height() const +{ + return _shape[kTileHeightIdx]; +} + +TileInfo &TileInfo::data_type(DataType dt) +{ + _dt = dt; + return *this; +} + +DataType TileInfo::data_type() const +{ + return _dt; +} +} // namespace ckw diff --git a/compute_kernel_writer/src/cl/CLHelpers.cpp b/compute_kernel_writer/src/cl/CLHelpers.cpp new file mode 100644 index 0000000000..68d7db252b --- /dev/null +++ b/compute_kernel_writer/src/cl/CLHelpers.cpp @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#include "ckw/Error.h" +#include "ckw/Types.h" + +#include "src/cl/CLHelpers.h" + +namespace ckw +{ +bool cl_validate_vector_length(int32_t len) +{ + bool valid_vector_length = true; + if(len < 1 || len > 16 || (len > 4 && len < 8) || (len > 8 && len < 16)) + { + valid_vector_length = false; + } + return valid_vector_length; +} + +std::string cl_get_variable_datatype_as_string(DataType dt, int32_t len) +{ + if(cl_validate_vector_length(len) == false) + { + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported vector length"); + return ""; + } + + std::string res; + switch(dt) + { + case DataType::Fp32: + res += "float"; + break; + case DataType::Fp16: + res += "half"; + break; + case DataType::Int8: + res += "char"; + break; + case DataType::Uint8: + res += "uchar"; + break; + case DataType::Uint16: + res += "ushort"; + break; + case DataType::Int16: + res += "short"; + break; + case DataType::Uint32: + res += "uint"; + break; + case DataType::Int32: + res += "int"; + break; + case DataType::Bool: + res += "bool"; + break; + default: + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported datatype"); + return ""; + } + + if(len > 1) + { + res += std::to_string(len); + } + + return res; +} +} // namespace ckw \ No newline at end of file diff --git a/compute_kernel_writer/src/cl/CLHelpers.h b/compute_kernel_writer/src/cl/CLHelpers.h new file mode 100644 index 0000000000..915d59f458 --- /dev/null +++ b/compute_kernel_writer/src/cl/CLHelpers.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_SRC_CL_CLHELPERS_H +#define COMPUTE_KERNEL_WRITER_SRC_CL_CLHELPERS_H + +#include + +/** OpenCL specific helper functions */ +namespace ckw +{ +// Forward declarations +enum class DataType; + +/** Helper function to validate the vector length of OpenCL vector data types + * + * @param[in] len Vector length + * + * @return true if the vector lenght is valid. It returns false, otherwise. + */ +bool cl_validate_vector_length(int32_t len); + +/** Helper function to return the OpenCL datatype as a string from a @ref DataType and vector length as int32_t variable + * + * @param[in] dt Datatype + * @param[in] len Vector length + * + * @return the OpenCL datatype as a string + */ +std::string cl_get_variable_datatype_as_string(DataType dt, int32_t len); +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_SRC_CL_CLHELPERS_H */ diff --git a/compute_kernel_writer/src/cl/CLTile.cpp b/compute_kernel_writer/src/cl/CLTile.cpp new file mode 100644 index 0000000000..a46f692a5c --- /dev/null +++ b/compute_kernel_writer/src/cl/CLTile.cpp @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#include "ckw/Error.h" +#include "ckw/TileInfo.h" + +#include "src/Helpers.h" +#include "src/cl/CLHelpers.h" +#include "src/cl/CLTile.h" + +#include +#include + +namespace ckw +{ +CLTile::CLTile(const std::string &name, const TileInfo &info) +{ + validate_tile_info(info); + + _basename = name; + _info = info; +} + +TileVariable CLTile::scalar(int32_t col, int32_t row) const +{ + // Clamp to nearest valid edge + col = clamp(col, static_cast(0), _info.width() - 1); + row = clamp(row, static_cast(0), _info.height() - 1); + + TileVariable t; + t.str = create_var_name(row); + t.desc.dt = _info.data_type(); + t.desc.len = 1; + + // This check is required because if the width has only one element, we cannot use .s0 + if(_info.width() != 1) + { + // Automatic broadcasting + t.str += ".s" + dec_to_hex_as_string(col); + } + + return t; +} + +TileVariable CLTile::vector(int32_t row) const +{ + // Clamp to nearest valid edge + row = clamp(row, static_cast(0), _info.height() - 1); + + TileVariable t; + t.str = create_var_name(row); + t.desc.dt = _info.data_type(); + t.desc.len = _info.width(); + return t; +} + +TileVariable CLTile::vector(int32_t col_start, int32_t width, int32_t row) const +{ + // Validate the new vector length + cl_validate_vector_length(width); + + // Clamp to nearest valid edge + row = clamp(row, static_cast(0), _info.height() - 1); + + TileVariable t; + t.str = create_var_name(row); + t.desc.dt = _info.data_type(); + t.desc.len = width; + + if(_info.width() != 1) + { + t.str += ".s"; + for(int i = 0; i < width; ++i) + { + t.str += dec_to_hex_as_string(col_start + i); + } + } + return t; +} + +std::vector CLTile::all() const +{ + std::vector vars; + for(int32_t y = 0; y < _info.height(); ++y) + { + TileVariable t; + t.str = create_var_name(y); + t.desc.dt = _info.data_type(); + t.desc.len = _info.width(); + vars.push_back(t); + } + return vars; +} + +std::vector CLTile::supported_vector_lengths() const +{ + return std::vector {1, 2, 3, 4, 8, 16}; +} + +bool CLTile::is_assignable() const +{ + return true; +} + +std::string CLTile::create_var_name(int32_t row) const +{ + std::string var_name = _basename; + + // If a scalar variable, we do not append the row index + if(_info.height() == 1) + { + return var_name; + + } + else + { + var_name += "_"; + var_name += std::to_string(row); + } + + return var_name; +} + +void CLTile::validate_tile_info(const TileInfo &info) const +{ + if(cl_validate_vector_length(info.width())) + { + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("Unsupported TileInfo width"); + } + + if(info.data_type() == DataType::Unknown) + { + COMPUTE_KERNEL_WRITER_ERROR_ON_MSG("DataType::Unknown is not supported"); + } +} +} // namespace ckw \ No newline at end of file diff --git a/compute_kernel_writer/src/cl/CLTile.h b/compute_kernel_writer/src/cl/CLTile.h new file mode 100644 index 0000000000..50801675a7 --- /dev/null +++ b/compute_kernel_writer/src/cl/CLTile.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_SRC_CL_CLTILE_H +#define COMPUTE_KERNEL_WRITER_SRC_CL_CLTILE_H + +#include "src/ITile.h" + +#include + +namespace ckw +{ +// Forward declarations +class TileInfo; + +/** OpenCL specific tile */ +class CLTile : protected IVectorTile +{ +public: + /** Constructor + * + * @param[in] name Tile name + * @param[in] info Tile info + */ + CLTile(const std::string& name, const TileInfo &info); + + // Inherited method overridden + TileVariable scalar(int32_t col, int32_t row) const override; + TileVariable vector(int32_t row) const override; + TileVariable vector(int32_t col_start, int32_t width, int32_t row) const override; + std::vector all() const override; + std::vector supported_vector_lengths() const override; + bool is_assignable() const override; + +private: + std::string create_var_name(int32_t row) const; + void validate_tile_info(const TileInfo &info) const; +}; +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_SRC_CL_CLTILE_H */ diff --git a/compute_kernel_writer/validation/SConscript b/compute_kernel_writer/validation/SConscript new file mode 100644 index 0000000000..452cc0a9ea --- /dev/null +++ b/compute_kernel_writer/validation/SConscript @@ -0,0 +1,100 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- + +# Copyright (c) 2023 Arm Limited. +# +# SPDX-License-Identifier: MIT +# +# 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.path + +Import('env') +Import('vars') +Import('install_bin') + +# vars is imported from compute_kernel_writer: +variables = [ + BoolVariable("validation_tests", "Build validation test programs", False) +] + +# We need a separate set of Variables for the Help message (Otherwise the global variables will get displayed twice) +new_options = Variables('scons') + +for v in variables: + new_options.Add(v) + vars.Add(v) + +# Clone the environment to make sure we're not polluting the compute_kernel_writer one: +test_env = env.Clone() +vars.Update(test_env) + +Help(new_options.GenerateHelpText(test_env)) + +# Check if we need to build the test framework +build_test_framework = False +for opt in new_options.keys(): + option_value = test_env[opt] + if type(option_value) is bool and option_value: + build_test_framework = True + break + +if not build_test_framework: + Return() + +# Remove -Wnoexcept from tests +if 'g++' in test_env['CXX'] and '-Wnoexcept' in test_env['CXXFLAGS']: + test_env['CXXFLAGS'].remove("-Wnoexcept") + +load_whole_archive = '-Wl,--whole-archive' +noload_whole_archive = '-Wl,--no-whole-archive' + +if env['os'] in ['android']: + Import("ckw_a") + + test_env.Append(LIBS = [ckw_a]) + ckw_lib = ckw_a +else: + Import("ckw_so") + test_env.Append(LIBS = ["ckw"]) + ckw_lib = ckw_so + +# Add main file +files_validation = Glob('Validation.cpp') + +# Add unit tests +files_validation += Glob('tests/*.cpp') + +extra_link_flags = [] + +test_env.Append(LIBS = ["rt"]) +extra_link_flags += ['-fstack-protector-strong'] + +bm_link_flags = [] +if test_env['linker_script']: + bm_link_flags += ['-Wl,--build-id=none', '-T', env['linker_script']] + +if test_env['validation_tests']: + program_objects = files_validation + + ckw_validation = test_env.Program('ckw_validation', program_objects, LIBS=test_env['LIBS'], LINKFLAGS=test_env['LINKFLAGS'] + bm_link_flags) + ckw_validation = install_bin(ckw_validation) + Depends(ckw_validation, ckw_lib) + + Default(ckw_validation) + Export('ckw_validation') diff --git a/compute_kernel_writer/validation/Validation.cpp b/compute_kernel_writer/validation/Validation.cpp new file mode 100644 index 0000000000..cc9dbfa7d0 --- /dev/null +++ b/compute_kernel_writer/validation/Validation.cpp @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ + +#include "tests/CLTileTest.hpp" +#include "tests/TensorBitMaskTest.hpp" +#include "tests/UtilsTest.hpp" + +#include +#include + +using namespace ckw; + +/** Main test program + */ +int32_t main() +{ + std::vector tests; + + // Add your test here + const auto test0 = std::make_unique(); + const auto test1 = std::make_unique(); + const auto test2 = std::make_unique(); + const auto test3 = std::make_unique(); + const auto test4 = std::make_unique(); + const auto test5 = std::make_unique(); + const auto test6 = std::make_unique(); + const auto test7 = std::make_unique(); + tests.push_back(test0.get()); + tests.push_back(test1.get()); + tests.push_back(test2.get()); + tests.push_back(test3.get()); + tests.push_back(test4.get()); + tests.push_back(test5.get()); + tests.push_back(test6.get()); + tests.push_back(test7.get()); + + bool all_test_passed = true; + + for(auto &x : tests) + { + std::cout << x->name() << std::endl; + all_test_passed &= x->run(); + } + + if(all_test_passed == true) + { + std::cout << "All tests passed" << std::endl; + } + else + { + std::cout << "One or more tests failed" << std::endl; + } + + return 0; +} diff --git a/compute_kernel_writer/validation/tests/CLTileTest.hpp b/compute_kernel_writer/validation/tests/CLTileTest.hpp new file mode 100644 index 0000000000..9fb47941f4 --- /dev/null +++ b/compute_kernel_writer/validation/tests/CLTileTest.hpp @@ -0,0 +1,311 @@ +#ifndef COMPUTE_KERNEL_WRITER_TESTS_CLTENSOR_HPP +#define COMPUTE_KERNEL_WRITER_TESTS_CLTENSOR_HPP + +#include "src/Helpers.h" +#include "src/cl/CLTile.h" +#include "common/Common.h" + +#include +#include + +namespace ckw +{ +class CLTileInternalVariableNamesTest : public ITest +{ +public: + const int32_t width = 4; + const int32_t height = 4; + const DataType dt = DataType::Fp32; + + CLTileInternalVariableNamesTest() + { + _tile_name.push_back("dst"); + _tile_name.push_back("_G0_dst"); + _tile_name.push_back("_SRC"); + } + + bool run() override + { + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + const TileInfo info(dt, width, height); + + const size_t num_tests = _tile_name.size(); + for(size_t i = 0; i < num_tests; ++i) + { + const std::string tile_name = _tile_name[i]; + const CLTile tile(tile_name, info); + const auto vars = tile.all(); + + for(int32_t y = 0; y < height; ++y) + { + const std::string expected_var_name = tile_name + "_" + std::to_string(y); + const std::string actual_var_name = vars[y].str; + VALIDATE_TEST(actual_var_name.compare(expected_var_name) == 0, all_tests_passed, i); + } + } + return all_tests_passed; + } + + std::string name() override + { + return "CLTileInternalVariableNamesTest"; + } + +private: + std::vector _tile_name {}; +}; + +class CLTileInternalNumVariablesTest : public ITest +{ +public: + CLTileInternalNumVariablesTest() + { + _width.push_back(4); + _width.push_back(1); + _width.push_back(16); + + _height.push_back(1); + _height.push_back(5); + _height.push_back(3); + } + + bool run() override + { + VALIDATE_ON_MSG(_width.size() == _height.size(), "The number of widths and heights does not match"); + + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + const size_t num_tests = _width.size(); + + for(size_t i = 0; i < num_tests; ++i) + { + const int32_t width = _width[i]; + const int32_t height = _height[i]; + const TileInfo info(DataType::Fp32, width, height); + const CLTile tile("src", info); + const auto vars = tile.all(); + const int32_t num_vars = vars.size(); + + // We expect the number of variables to match the heigth of the tile + VALIDATE_TEST(num_vars == height, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "CLTileInternalNumVariablesTest"; + } + +private: + std::vector _width {}; + std::vector _height {}; +}; + +class CLTileAccessScalarVariableTest : public ITest +{ +public: + const std::string tile_name = "src"; + const int32_t width = 16; + const int32_t height = 8; + const DataType dt = DataType::Fp32; + + CLTileAccessScalarVariableTest() + { + _x_coord.push_back(4); + _x_coord.push_back(1); + _x_coord.push_back(15); + _x_coord.push_back(10); + + _y_coord.push_back(1); + _y_coord.push_back(5); + _y_coord.push_back(3); + _y_coord.push_back(4); + } + + bool run() override + { + const TileInfo info(dt, width, height); + const CLTile tile(tile_name, info); + + VALIDATE_ON_MSG(_x_coord.size() == _y_coord.size(), "The number of x-coords and y-coords does not match"); + + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + const size_t num_tests = _x_coord.size(); + + for(size_t i = 0; i < num_tests; ++i) + { + const int32_t x_coord = _x_coord[i]; + const int32_t y_coord = _y_coord[i]; + + const TileVariable var = tile.scalar(x_coord, y_coord); + + const std::string expected_var_name = var.str; + std::string actual_var_name = tile_name; + actual_var_name += "_" + std::to_string(y_coord); + actual_var_name += ".s" + dec_to_hex_as_string(x_coord); + + VALIDATE_TEST(actual_var_name.compare(expected_var_name) == 0, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "CLTileAccessScalarVariableTest"; + } + +private: + std::vector _x_coord {}; + std::vector _y_coord {}; +}; + +class CLTileAccessScalarVariableBroadcastXTest : public ITest +{ +public: + const std::string tile_name = "src"; + const int32_t height = 8; + const DataType dt = DataType::Fp32; + + CLTileAccessScalarVariableBroadcastXTest() + { + _width.push_back(1); + _width.push_back(2); + _width.push_back(3); + + _x_coord.push_back(4); + _x_coord.push_back(5); + _x_coord.push_back(6); + + _y_coord.push_back(1); + _y_coord.push_back(3); + _y_coord.push_back(2); + } + + bool run() override + { + VALIDATE_ON_MSG(_width.size() == _y_coord.size(), "The number of widths and y-coords does not match"); + VALIDATE_ON_MSG(_x_coord.size() == _y_coord.size(), "The number of x-coords and y-coords does not match"); + + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + const size_t num_tests = _x_coord.size(); + + for(size_t i = 0; i < num_tests; ++i) + { + const int32_t width = _width[i]; + const int32_t x_coord = _x_coord[i]; + const int32_t y_coord = _y_coord[i]; + + const int32_t x_coord_clamped = clamp(x_coord, static_cast(0), width - 1); + + const TileInfo info(dt, width, height); + const CLTile tile(tile_name, info); + + const TileVariable var = tile.scalar(x_coord, y_coord); + + const std::string expected_var_name = var.str; + std::string actual_var_name = tile_name; + actual_var_name += "_" + std::to_string(y_coord); + if(width != 1) + { + actual_var_name += ".s" + dec_to_hex_as_string(x_coord_clamped); + } + + VALIDATE_TEST(actual_var_name.compare(expected_var_name) == 0, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "CLTileAccessScalarVariableBroadcastXTest"; + } + +private: + std::vector _width {}; + std::vector _x_coord {}; + std::vector _y_coord {}; +}; + +class CLTileAccessScalarVariableBroadcastYTest : public ITest +{ +public: + const std::string tile_name = "src"; + const int32_t width = 8; + const DataType dt = DataType::Fp32; + + CLTileAccessScalarVariableBroadcastYTest() + { + _height.push_back(1); + _height.push_back(2); + _height.push_back(3); + + _x_coord.push_back(4); + _x_coord.push_back(5); + _x_coord.push_back(6); + + _y_coord.push_back(3); + _y_coord.push_back(4); + _y_coord.push_back(5); + } + + bool run() override + { + VALIDATE_ON_MSG(_height.size() == _y_coord.size(), "The number of widths and y-coords does not match"); + VALIDATE_ON_MSG(_x_coord.size() == _y_coord.size(), "The number of x-coords and y-coords does not match"); + + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + const size_t num_tests = _x_coord.size(); + + for(size_t i = 0; i < num_tests; ++i) + { + const int32_t height = _height[i]; + const int32_t x_coord = _x_coord[i]; + const int32_t y_coord = _y_coord[i]; + + const int32_t y_coord_clamped = clamp(y_coord, static_cast(0), height - 1); + + const TileInfo info(dt, width, height); + const CLTile tile(tile_name, info); + + const TileVariable var = tile.scalar(x_coord, y_coord); + + const std::string expected_var_name = var.str; + std::string actual_var_name = tile_name; + if(height != 1) + { + actual_var_name += "_" + std::to_string(y_coord_clamped); + } + + if(width != 1) + { + actual_var_name += ".s" + dec_to_hex_as_string(x_coord); + } + + VALIDATE_TEST(actual_var_name.compare(expected_var_name) == 0, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "CLTileAccessScalarVariableBroadcastYTest"; + } + +private: + std::vector _height {}; + std::vector _x_coord {}; + std::vector _y_coord {}; +}; +} + +#endif /* COMPUTE_KERNEL_WRITER_TESTS_CLTENSOR_HPP */ diff --git a/compute_kernel_writer/validation/tests/TensorBitMaskTest.hpp b/compute_kernel_writer/validation/tests/TensorBitMaskTest.hpp new file mode 100644 index 0000000000..a1a3588394 --- /dev/null +++ b/compute_kernel_writer/validation/tests/TensorBitMaskTest.hpp @@ -0,0 +1,217 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_TESTS_TENSORBITMASK_HPP +#define COMPUTE_KERNEL_WRITER_TESTS_TENSORBITMASK_HPP + +#include "ckw/TensorInfo.h" +#include "common/Common.h" + +#include + +namespace ckw +{ +class TensorBitMaskTrueTest : public ITest +{ +public: + TensorBitMaskTrueTest() + { + _component.push_back(TensorComponent::Dim0); + _component.push_back(TensorComponent::Dim1); + _component.push_back(TensorComponent::Dim2); + _component.push_back(TensorComponent::Dim3); + _component.push_back(TensorComponent::Dim4); + _component.push_back(TensorComponent::Stride0); + _component.push_back(TensorComponent::Stride1); + _component.push_back(TensorComponent::Stride2); + _component.push_back(TensorComponent::Stride3); + _component.push_back(TensorComponent::Stride4); + _component.push_back(TensorComponent::Dim1xDim2); + _component.push_back(TensorComponent::Dim1xDim2xDim3); + _component.push_back(TensorComponent::Dim2xDim3); + _component.push_back(TensorComponent::OffsetFirstElement); + + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + } + + bool run() override + { + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + VALIDATE_ON_MSG(_component.size() == _bitmask.size(), "The number of layouts and components does not match"); + const size_t num_tests = _component.size(); + for(size_t i = 0; i < num_tests; ++i) + { + const TensorComponent component = _component[i]; + const TensorComponentBitmask bitmask = _bitmask[i]; + const bool out = static_cast(component) & static_cast(bitmask); + VALIDATE_TEST(out == true, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "TensorBitMaskTrueTest"; + } + +private: + std::vector _component {}; + std::vector _bitmask {}; +}; + +class TensorBitMaskFalseTest : public ITest +{ +public: + TensorBitMaskFalseTest() + { + _component.push_back(TensorComponent::Dim0); + _component.push_back(TensorComponent::Dim1); + _component.push_back(TensorComponent::Dim2); + _component.push_back(TensorComponent::Dim3); + _component.push_back(TensorComponent::Dim4); + _component.push_back(TensorComponent::Dim0); + _component.push_back(TensorComponent::Dim1); + _component.push_back(TensorComponent::Dim2); + _component.push_back(TensorComponent::Dim3); + _component.push_back(TensorComponent::Dim4); + _component.push_back(TensorComponent::Dim0); + _component.push_back(TensorComponent::Dim1); + _component.push_back(TensorComponent::Dim2); + _component.push_back(TensorComponent::Dim3); + _component.push_back(TensorComponent::Dim4); + _component.push_back(TensorComponent::Stride0); + _component.push_back(TensorComponent::Stride1); + _component.push_back(TensorComponent::Stride2); + _component.push_back(TensorComponent::Stride3); + _component.push_back(TensorComponent::Stride4); + _component.push_back(TensorComponent::Stride0); + _component.push_back(TensorComponent::Stride1); + _component.push_back(TensorComponent::Stride2); + _component.push_back(TensorComponent::Stride3); + _component.push_back(TensorComponent::Stride4); + _component.push_back(TensorComponent::Stride0); + _component.push_back(TensorComponent::Stride1); + _component.push_back(TensorComponent::Stride2); + _component.push_back(TensorComponent::Stride3); + _component.push_back(TensorComponent::Stride4); + _component.push_back(TensorComponent::Dim1xDim2); + _component.push_back(TensorComponent::Dim1xDim2xDim3); + _component.push_back(TensorComponent::Dim2xDim3); + _component.push_back(TensorComponent::Dim1xDim2); + _component.push_back(TensorComponent::Dim1xDim2xDim3); + _component.push_back(TensorComponent::Dim2xDim3); + _component.push_back(TensorComponent::Dim1xDim2); + _component.push_back(TensorComponent::Dim1xDim2xDim3); + _component.push_back(TensorComponent::Dim2xDim3); + _component.push_back(TensorComponent::OffsetFirstElement); + _component.push_back(TensorComponent::OffsetFirstElement); + _component.push_back(TensorComponent::OffsetFirstElement); + + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::OffsetFirstElement); + _bitmask.push_back(TensorComponentBitmask::Dimension); + _bitmask.push_back(TensorComponentBitmask::Stride); + _bitmask.push_back(TensorComponentBitmask::FoldedDimensions); + } + + bool run() override + { + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + VALIDATE_ON_MSG(_component.size() == _bitmask.size(), "The number of layouts and components does not match"); + const size_t num_tests = _component.size(); + for(size_t i = 0; i < num_tests; ++i) + { + const TensorComponent component = _component[i]; + const TensorComponentBitmask bitmask = _bitmask[i]; + const bool out = static_cast(component) & static_cast(bitmask); + VALIDATE_TEST(out == false, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "TensorBitMaskFalseTest"; + } + +private: + std::vector _component {}; + std::vector _bitmask {}; +}; +} + +#endif /* COMPUTE_KERNEL_WRITER_TESTS_TENSORBITMASK_HPP */ diff --git a/compute_kernel_writer/validation/tests/UtilsTest.hpp b/compute_kernel_writer/validation/tests/UtilsTest.hpp new file mode 100644 index 0000000000..4a09d53f73 --- /dev/null +++ b/compute_kernel_writer/validation/tests/UtilsTest.hpp @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_TESTS_UTILSTEST_HPP +#define COMPUTE_KERNEL_WRITER_TESTS_UTILSTEST_HPP + +#include "ckw/TensorInfo.h" +#include "src/TensorUtils.h" +#include "common/Common.h" + +#include + +namespace ckw +{ +class UtilsTest : public ITest +{ +public: + UtilsTest() + { + _layout.push_back(TensorDataLayout::Nhwc); + _layout.push_back(TensorDataLayout::Nhwc); + _layout.push_back(TensorDataLayout::Nhwc); + _layout.push_back(TensorDataLayout::Nhwc); + _layout.push_back(TensorDataLayout::Ndhwc); + _layout.push_back(TensorDataLayout::Ndhwc); + _layout.push_back(TensorDataLayout::Ndhwc); + _layout.push_back(TensorDataLayout::Ndhwc); + _layout.push_back(TensorDataLayout::Ndhwc); + + _component.push_back(TensorDataLayoutComponent::N); + _component.push_back(TensorDataLayoutComponent::H); + _component.push_back(TensorDataLayoutComponent::W); + _component.push_back(TensorDataLayoutComponent::C); + _component.push_back(TensorDataLayoutComponent::N); + _component.push_back(TensorDataLayoutComponent::D); + _component.push_back(TensorDataLayoutComponent::H); + _component.push_back(TensorDataLayoutComponent::W); + _component.push_back(TensorDataLayoutComponent::C); + + _expected.push_back(TensorComponent::Dim3); + _expected.push_back(TensorComponent::Dim2); + _expected.push_back(TensorComponent::Dim1); + _expected.push_back(TensorComponent::Dim0); + _expected.push_back(TensorComponent::Dim4); + _expected.push_back(TensorComponent::Dim3); + _expected.push_back(TensorComponent::Dim2); + _expected.push_back(TensorComponent::Dim1); + _expected.push_back(TensorComponent::Dim0); + } + + bool run() override + { + // The status of this variable can change in VALIDATE_TEST() + bool all_tests_passed = true; + + VALIDATE_ON_MSG(_layout.size() == _component.size(), "The number of layouts and components does not match"); + VALIDATE_ON_MSG(_layout.size() == _expected.size(), "The number of layouts and expected outputs does not match"); + const size_t num_tests = _layout.size(); + for(size_t i = 0; i < num_tests; ++i) + { + const TensorDataLayout layout = _layout[i]; + const TensorDataLayoutComponent component = _component[i]; + const TensorComponent expected = _expected[i]; + const TensorComponent out = get_tensor_dimension(layout, component); + VALIDATE_TEST(out == expected, all_tests_passed, i); + } + return all_tests_passed; + } + + std::string name() override + { + return "UtilsTest"; + } + +private: + std::vector _layout {}; + std::vector _component {}; + std::vector _expected {}; +}; +} + +#endif /* COMPUTE_KERNEL_WRITER_TESTS_UTILSTEST_HPP */ diff --git a/compute_kernel_writer/validation/tests/common/Common.h b/compute_kernel_writer/validation/tests/common/Common.h new file mode 100644 index 0000000000..d33d7f6688 --- /dev/null +++ b/compute_kernel_writer/validation/tests/common/Common.h @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2023 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * 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. + */ +#ifndef COMPUTE_KERNEL_WRITER_TEST_COMMON_COMMON_H +#define COMPUTE_KERNEL_WRITER_TEST_COMMON_COMMON_H + +#include +#include +#include + +namespace ckw +{ +#define VALIDATE_ON_MSG(exp, msg) assert(((void)msg, exp)) + +#define VALIDATE_TEST(exp, all_tests_passed, id_test) \ + do \ + { \ + if((exp) == true) \ + { \ + all_tests_passed &= true; \ + const std::string msg = "TEST " + std::to_string((id_test)) + ": [PASSED]"; \ + std::cout << msg << std::endl; \ + } \ + else \ + { \ + all_tests_passed &= false; \ + const std::string msg = "TEST " + std::to_string((id_test)) + ": [FAILED]"; \ + std::cout << msg << std::endl; \ + } \ + } while(false) + +class ITest +{ +public: + virtual ~ITest() = default; + /** Method to run the test + * + * @return it returns true if all tests passed + */ + virtual bool run() = 0; + /** Name of the test + * + * @return it returns the name of the test + */ + virtual std::string name() = 0; +}; +} // namespace ckw + +#endif /* COMPUTE_KERNEL_WRITER_TEST_COMMON_COMMON_H */ diff --git a/scripts/clang_tidy_rules.py b/scripts/clang_tidy_rules.py index 2e0b32e6cc..3e98e85ad3 100755 --- a/scripts/clang_tidy_rules.py +++ b/scripts/clang_tidy_rules.py @@ -70,6 +70,9 @@ def filter_clang_tidy_lines( lines ): if "/arm_gemm/" in line: continue + if "compute_kernel_writer/" in line: + continue + if "/convolution/" in line: continue -- cgit v1.2.1