Add online compilation for dynamic kernels (#37)

* Add online-compiling facility

* Synchronize from fwd-v4r5 and implement host interfaces to call conv-fwd v4r4/v4r5 using on-line compiling method

* Tiny adjustment to time reporting

* Use object assignment to replace explicit bytes copying in the first kernel of v4r4/v4r5

* Use single thread to assign descriptor object to device memory

* Adjust to the workload assignment of the two kernels of v4r4 (experimental)

* Revert "Adjust to the workload assignment of the two kernels of v4r4 (experimental)"

This reverts commit eb38461456bb0c82b6c0d32cdd616e181907e20c.

* Update to make constexpr for generating descriptor types in kernel 2 of dynamic conv-fwd v4r4

* Update to dynamic conv-fwd v4r4 online-compiling

* Update to dynamic conv-fwd v4r5 online-compiling (result not accurate)

* Tiny update to driver/CMakeLists.txt

* clang-format

* Tiny comments change

* Add env OLC_DUMP_SAVE_TMP_DIR to support saving of temperary dir

* Fwd v4r5 olc perf (#39)

* added hip-clang flags that fix perf issue of online compilation

* fix bug for olc fwd-v4r5-nchw

* Move constexpr and type reference statements out of the function body in conv-fwd v4r4/v4r5 kernel wrapper

* Remove printing in hip_build_utils.cpp

* Update to root CMakeLists.txt

* Revert "Move constexpr and type reference statements out of the function body in conv-fwd v4r4/v4r5 kernel wrapper"

This reverts commit 3d2c5d8ecdd8298b72d127110500ed5b38d9835c.
Co-authored-by: Chao Liu <chao.liu2@amd.com>
Co-authored-by: Chao Liu <lc.roy86@gmail.com>
Co-authored-by: root <root@dc-smc-18.amd.com>

driver/olCompiling/addkernels/CMakeLists.txt

+################################################################################
+# 
+# MIT License
+# 
+# Copyright (c) 2017 Advanced Micro Devices, Inc.
+# 
+# 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.
+# 
+################################################################################
+
+set(ADD_KERNELS_SOURCE include_inliner.cpp addkernels.cpp)
+
+add_executable(addkernels EXCLUDE_FROM_ALL ${ADD_KERNELS_SOURCE})
+

driver/olCompiling/addkernels/addkernels.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2021 Advanced Micro Devices, Inc.
+ *
+ * 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 "include_inliner.hpp"
+#include <algorithm>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+void Bin2Hex(std::istream& source,
+             std::ostream& target,
+             const std::string& variable,
+             bool nullTerminate,
+             size_t bufferSize,
+             size_t lineSize)
+{
+    source.seekg(0, std::ios::end);
+    std::unique_ptr<unsigned char[]> buffer(new unsigned char[bufferSize]);
+    std::streamoff sourceSize = source.tellg();
+    std::streamoff blockStart = 0;
+
+    if(variable.length() != 0)
+    {
+        target << "extern const size_t " << variable << "_SIZE;" << std::endl;
+        target << "extern const unsigned char " << variable << "[];" << std::endl;
+        target << "const size_t " << variable << "_SIZE = " << std::setbase(10) << sourceSize << ";"
+               << std::endl;
+        target << "const unsigned char " << variable << "[] = {" << std::endl;
+    }
+
+    target << std::setbase(16) << std::setfill('0');
+    source.seekg(0, std::ios::beg);
+
+    while(blockStart < sourceSize)
+    {
+        source.read(reinterpret_cast<char*>(buffer.get()), bufferSize);
+
+        std::streamoff pos       = source.tellg();
+        std::streamoff blockSize = (pos < 0 ? sourceSize : pos) - blockStart;
+        std::streamoff i         = 0;
+
+        while(i < blockSize)
+        {
+            size_t j   = i;
+            size_t end = std::min<size_t>(i + lineSize, blockSize);
+
+            for(; j < end; j++)
+                target << "0x" << std::setw(2) << static_cast<unsigned>(buffer[j]) << ",";
+
+            target << std::endl;
+            i = end;
+        }
+
+        blockStart += blockSize;
+    }
+
+    if(nullTerminate)
+        target << "0x00," << std::endl;
+
+    if(variable.length() != 0)
+    {
+        target << "};" << std::endl;
+    }
+}
+
+void PrintHelp()
+{
+    std::cout << "Usage: bin2hex {<option>}" << std::endl;
+    std::cout << "Option format: -<option name>[ <option value>]" << std::endl;
+    std::cout << std::endl;
+    std::cout << "Options:" << std::endl;
+    std::cout
+        << "[REQUIRED] -s[ource] {<path to file>}: files to be processed. Must be last argument."
+        << std::endl;
+    std::cout << "           -t[arget] <path>: target file. Default: std out." << std::endl;
+    std::cout << "           -l[ine-size] <number>: bytes in one line. Default: 16." << std::endl;
+    std::cout << "           -b[uffer] <number>: read buffer size. Default: 512." << std::endl;
+    std::cout << "           -g[uard] <string>: guard name. Default: no guard" << std::endl;
+    std::cout << "           -n[o-recurse] : dont expand include files recursively. Default: off"
+              << std::endl;
+}
+
+[[gnu::noreturn]] void WrongUsage(const std::string& error)
+{
+    std::cout << "Wrong usage: " << error << std::endl;
+    std::cout << std::endl;
+    PrintHelp();
+    std::exit(1);
+}
+
+[[gnu::noreturn]] void UnknownArgument(const std::string& arg)
+{
+    std::ostringstream ss;
+    ss << "unknown argument - " << arg;
+    WrongUsage(ss.str());
+}
+
+void Process(const std::string& sourcePath,
+             std::ostream& target,
+             size_t bufferSize,
+             size_t lineSize,
+             bool recurse,
+             bool as_extern)
+{
+    std::string fileName(sourcePath);
+    std::string extension, root;
+    std::stringstream inlinerTemp;
+    auto extPos   = fileName.rfind('.');
+    auto slashPos = fileName.rfind('/');
+
+    if(extPos != std::string::npos)
+    {
+        extension = fileName.substr(extPos + 1);
+        fileName  = fileName.substr(0, extPos);
+    }
+
+    if(slashPos != std::string::npos)
+    {
+        root     = fileName.substr(0, slashPos + 1);
+        fileName = fileName.substr(slashPos + 1);
+    }
+
+    std::string variable(fileName);
+    std::ifstream sourceFile(sourcePath, std::ios::in | std::ios::binary);
+    std::istream* source = &sourceFile;
+
+    if(!sourceFile.good())
+    {
+        std::cerr << "File not found: " << sourcePath << std::endl;
+        std::exit(1);
+    }
+
+    const auto is_asm    = extension == "s";
+    const auto is_cl     = extension == "cl";
+    const auto is_hip    = extension == "cpp";
+    const auto is_header = extension == "hpp";
+
+    if(is_asm || is_cl || is_hip || is_header)
+    {
+        IncludeInliner inliner;
+
+        try
+        {
+            if(is_asm)
+                inliner.Process(
+                    sourceFile, inlinerTemp, root, sourcePath, ".include", false, recurse);
+            else if(is_cl || is_header)
+                inliner.Process(
+                    sourceFile, inlinerTemp, root, sourcePath, "#include", true, recurse);
+            else if(is_hip)
+                inliner.Process(
+                    sourceFile, inlinerTemp, root, sourcePath, "<#not_include>", true, false);
+        }
+        catch(const InlineException& ex)
+        {
+            std::cerr << ex.What() << std::endl;
+            std::cerr << ex.GetTrace() << std::endl;
+            std::exit(1);
+        }
+
+        source = &inlinerTemp;
+    }
+
+    std::transform(variable.begin(), variable.end(), variable.begin(), ::toupper);
+
+    if(as_extern && variable.length() != 0)
+    {
+        variable = "APP_KERNEL_" + variable;
+    }
+
+    Bin2Hex(*source, target, variable, true, bufferSize, lineSize);
+}
+
+int main(int argsn, char** args)
+{
+    if(argsn == 1)
+    {
+        PrintHelp();
+        return 2;
+    }
+
+    std::string guard;
+    size_t bufferSize = 512;
+    size_t lineSize   = 16;
+
+    std::ofstream targetFile;
+    std::ostream* target = &std::cout;
+    bool recurse         = true;
+    bool as_extern       = false;
+
+    int i = 0;
+    while(++i < argsn && **args != '-')
+    {
+        std::string arg(args[i] + 1);
+        std::transform(arg.begin(), arg.end(), arg.begin(), ::tolower);
+
+        if(arg == "s" || arg == "source")
+        {
+            if(guard.length() > 0)
+            {
+                *target << "#ifndef " << guard << std::endl;
+                *target << "#define " << guard << std::endl;
+            }
+
+            *target << "#include <cstddef>" << std::endl;
+
+            while(++i < argsn)
+            {
+                Process(args[i], *target, bufferSize, lineSize, recurse, as_extern);
+            }
+
+            if(guard.length() > 0)
+            {
+                *target << "#endif" << std::endl;
+            }
+
+            return 0;
+        }
+        else if(arg == "t" || arg == "target")
+        {
+            targetFile.open(args[++i], std::ios::out);
+            target = &targetFile;
+        }
+        else if(arg == "l" || arg == "line-size")
+            lineSize = std::stol(args[++i]);
+        else if(arg == "b" || arg == "buffer")
+            bufferSize = std::stol(args[++i]);
+        else if(arg == "g" || arg == "guard")
+            guard = args[++i];
+        else if(arg == "n" || arg == "no-recurse")
+            recurse = false;
+        else if(arg == "e" || arg == "extern")
+            as_extern = true;
+        else
+            UnknownArgument(arg);
+    }
+
+    WrongUsage("source key is required");
+}

driver/olCompiling/addkernels/include_inliner.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2021 Advanced Micro Devices, Inc.
+ *
+ * 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 <algorithm>
+#include <exception>
+#include <fstream>
+#include <sstream>
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+#ifdef __linux__
+#include <linux/limits.h>
+#include <cstdlib>
+#endif // !WIN32
+
+#include "include_inliner.hpp"
+
+namespace PathHelpers {
+static int GetMaxPath()
+{
+#ifdef _WIN32
+    return MAX_PATH;
+#else
+    return PATH_MAX;
+#endif
+}
+
+static std::string GetAbsolutePath(const std::string& path)
+{
+    std::string result(GetMaxPath(), ' ');
+#ifdef _WIN32
+    const auto retval = GetFullPathName(path.c_str(), result.size(), &result[0], nullptr);
+
+    if(retval == 0)
+        return "";
+#else
+    auto* const retval = realpath(path.c_str(), &result[0]);
+
+    if(retval == nullptr)
+        return "";
+#endif
+    return result;
+}
+} // namespace PathHelpers
+
+std::string IncludeFileExceptionBase::What() const
+{
+    std::ostringstream ss;
+    ss << GetMessage() << ": <" << _file << ">";
+
+    return ss.str();
+}
+
+void IncludeInliner::Process(std::istream& input,
+                             std::ostream& output,
+                             const std::string& root,
+                             const std::string& file_name,
+                             const std::string& directive,
+                             bool allow_angle_brackets,
+                             bool recurse)
+{
+    ProcessCore(input, output, root, file_name, 0, directive, allow_angle_brackets, recurse);
+}
+
+void IncludeInliner::ProcessCore(std::istream& input,
+                                 std::ostream& output,
+                                 const std::string& root,
+                                 const std::string& file_name,
+                                 int line_number,
+                                 const std::string& directive,
+                                 bool allow_angle_brackets,
+                                 bool recurse)
+{
+    if(_include_depth >= include_depth_limit)
+        throw InlineStackOverflowException(GetIncludeStackTrace(0));
+
+    _include_depth++;
+    _included_stack_head =
+        std::make_shared<SourceFileDesc>(file_name, _included_stack_head, line_number);
+    auto current_line          = 0;
+    auto next_include_optional = false;
+
+    while(!input.eof())
+    {
+        std::string line;
+        std::string word;
+        std::getline(input, line);
+        std::istringstream line_parser(line);
+        line_parser >> word;
+        current_line++;
+        std::transform(word.begin(), word.end(), word.begin(), ::tolower);
+
+        const auto include_optional = next_include_optional;
+        next_include_optional       = false;
+
+        if(!word.empty() && word == "//inliner-include-optional")
+        {
+            if(include_optional)
+                throw IncludeExpectedException(GetIncludeStackTrace(current_line));
+            next_include_optional = true;
+            continue;
+        }
+
+        if(!word.empty() && word == directive && recurse)
+        {
+            auto first_quote_pos = line.find('"', static_cast<int>(line_parser.tellg()) + 1);
+            std::string::size_type second_quote_pos;
+
+            if(first_quote_pos != std::string::npos)
+            {
+                second_quote_pos = line.find('"', first_quote_pos + 1);
+                if(second_quote_pos == std::string::npos)
+                    throw WrongInlineDirectiveException(GetIncludeStackTrace(current_line));
+            }
+            else
+            {
+                if(!allow_angle_brackets)
+                    throw WrongInlineDirectiveException(GetIncludeStackTrace(current_line));
+
+                first_quote_pos = line.find('<', static_cast<int>(line_parser.tellg()) + 1);
+                if(first_quote_pos == std::string::npos)
+                    throw WrongInlineDirectiveException(GetIncludeStackTrace(current_line));
+
+                second_quote_pos = line.find('>', first_quote_pos + 1);
+                if(second_quote_pos == std::string::npos)
+                    throw WrongInlineDirectiveException(GetIncludeStackTrace(current_line));
+            }
+
+            const std::string include_file_path =
+                line.substr(first_quote_pos + 1, second_quote_pos - first_quote_pos - 1);
+            const std::string abs_include_file_path(
+                PathHelpers::GetAbsolutePath(root + "/" + include_file_path)); // NOLINT
+
+            if(abs_include_file_path.empty())
+            {
+                if(include_optional)
+                    continue;
+                throw IncludeNotFoundException(include_file_path,
+                                               GetIncludeStackTrace(current_line));
+            }
+            std::ifstream include_file(abs_include_file_path, std::ios::in);
+
+            if(!include_file.good())
+                throw IncludeCantBeOpenedException(include_file_path,
+                                                   GetIncludeStackTrace(current_line));
+
+            ProcessCore(include_file,
+                        output,
+                        root,
+                        include_file_path,
+                        current_line,
+                        directive,
+                        allow_angle_brackets,
+                        recurse);
+        }
+        else
+        {
+            if(include_optional)
+                throw IncludeExpectedException(GetIncludeStackTrace(current_line));
+
+            if(output.tellp() > 0)
+                output << std::endl;
+
+            output << line;
+        }
+    }
+
+    auto prev_file       = _included_stack_head->included_from;
+    _included_stack_head = prev_file;
+    _include_depth--;
+}
+
+std::string IncludeInliner::GetIncludeStackTrace(int line)
+{
+    std::ostringstream ss;
+
+    if(_included_stack_head == nullptr)
+        return "";
+
+    auto item = _included_stack_head;
+    ss << "    " << item->path << ":" << line;
+
+    while(item->included_from != nullptr)
+    {
+        ss << std::endl << "    from " << item->included_from->path << ":" << item->included_line;
+        item = item->included_from;
+    }
+
+    return ss.str();
+}

driver/olCompiling/addkernels/include_inliner.hpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2021 Advanced Micro Devices, Inc.
+ *
+ * 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 SOURCE_INLINER_HPP
+
+#define SOURCE_INLINER_HPP
+#include "source_file_desc.hpp"
+#include <ostream>
+#include <memory>
+#include <stack>
+
+class InlineException : public std::exception
+{
+    public:
+    InlineException(const std::string& trace) : _trace(trace) {}
+
+    virtual std::string What() const = 0;
+    const std::string& GetTrace() const { return _trace; }
+
+    private:
+    std::string _trace;
+};
+
+class InlineStackOverflowException : public InlineException
+{
+    public:
+    InlineStackOverflowException(const std::string& trace) : InlineException(trace) {}
+
+    std::string What() const override
+    {
+        return "Include stack depth limit has been reached, possible circle includes";
+    }
+};
+
+class IncludeExpectedException : public InlineException
+{
+    public:
+    IncludeExpectedException(const std::string& trace) : InlineException(trace) {}
+
+    std::string What() const override { return "Include directive expected"; }
+};
+
+class WrongInlineDirectiveException : public InlineException
+{
+    public:
+    WrongInlineDirectiveException(const std::string& trace) : InlineException(trace) {}
+
+    std::string What() const override { return "Include directive has wrong format"; }
+};
+
+class IncludeFileExceptionBase : public InlineException
+{
+    public:
+    IncludeFileExceptionBase(const std::string& file, const std::string& trace)
+        : InlineException(trace), _file(file)
+    {
+    }
+
+    std::string What() const override;
+    virtual std::string GetMessage() const = 0;
+
+    private:
+    std::string _file;
+};
+
+class IncludeNotFoundException : public IncludeFileExceptionBase
+{
+    public:
+    IncludeNotFoundException(const std::string& file, const std::string& trace)
+        : IncludeFileExceptionBase(file, trace)
+    {
+    }
+
+    std::string GetMessage() const override
+    {
+        return "Include file not found (if it is optional put //inliner-include-optional on line "
+               "before it)";
+    }
+};
+
+class IncludeCantBeOpenedException : public IncludeFileExceptionBase
+{
+    public:
+    IncludeCantBeOpenedException(const std::string& file, const std::string& trace)
+        : IncludeFileExceptionBase(file, trace)
+    {
+    }
+
+    std::string GetMessage() const override { return "Can not open include file"; }
+};
+
+class IncludeInliner
+{
+    public:
+    int include_depth_limit = 256;
+
+    void Process(std::istream& input,
+                 std::ostream& output,
+                 const std::string& root,
+                 const std::string& file_name,
+                 const std::string& directive,
+                 bool allow_angle_brackets,
+                 bool recurse);
+    std::string GetIncludeStackTrace(int line);
+
+    private:
+    int _include_depth                                   = 0;
+    std::shared_ptr<SourceFileDesc> _included_stack_head = nullptr;
+
+    void ProcessCore(std::istream& input,
+                     std::ostream& output,
+                     const std::string& root,
+                     const std::string& file_name,
+                     int line_number,
+                     const std::string& directive,
+                     bool allow_angle_brackets,
+                     bool recurse);
+};
+
+#endif // !SOURCE_INLINER_HPP

driver/olCompiling/addkernels/source_file_desc.hpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2021 Advanced Micro Devices, Inc.
+ *
+ * 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 SOURCE_FILE_DESC_HPP
+
+#define SOURCE_FILE_DESC_HPP
+#include <string>
+#include <memory>
+
+class SourceFileDesc
+{
+    public:
+    const std::string path;
+    int included_line;
+    std::shared_ptr<SourceFileDesc> included_from;
+
+    SourceFileDesc(const std::string& path_, std::shared_ptr<SourceFileDesc> from, int line)
+        : path(path_), included_line(line), included_from(from)
+    {
+    }
+};
+
+#endif // SOURCE_FILE_DESC_HPP

driver/olCompiling/hip_utility/binary_cache.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Advanced Micro Devices, Inc.
+ *
+ * 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 <binary_cache.hpp>
+#include <handle.hpp>
+#include <md5.hpp>
+#include <env.hpp>
+#include <stringutils.hpp>
+#include <logger.hpp>
+#include <target_properties.hpp>
+#include <boost/filesystem.hpp>
+#include <fstream>
+#include <iostream>
+
+namespace olCompile {
+
+OLC_DECLARE_ENV_VAR(OLC_DISABLE_CACHE)
+OLC_DECLARE_ENV_VAR(HOME)
+
+static boost::filesystem::path ComputeCachePath()
+{
+    const char* home_dir = GetStringEnv(HOME{});
+    if(home_dir == nullptr || home_dir == std::string("/") || home_dir == std::string(""))
+    {
+        home_dir = "/tmp";
+    }
+
+    auto p = boost::filesystem::path{home_dir} / "_hip_binary_kernels_";
+
+    if(!boost::filesystem::exists(p))
+        boost::filesystem::create_directories(p);
+    return p;
+}
+
+boost::filesystem::path GetCachePath()
+{
+    static const boost::filesystem::path user_path = ComputeCachePath();
+
+    return user_path;
+}
+
+static bool IsCacheDisabled() { return olCompile::IsEnabled(OLC_DISABLE_CACHE{}); }
+
+boost::filesystem::path
+GetCacheFile(const std::string& device, const std::string& name, const std::string& args)
+{
+    // std::string filename = (is_kernel_str ? olCompile::md5(name) : name) + ".o";
+    std::string filename = name + ".o";
+    return GetCachePath() / olCompile::md5(device + ":" + args) / filename;
+}
+
+boost::filesystem::path LoadBinary(const TargetProperties& target,
+                                   const size_t num_cu,
+                                   const std::string& name,
+                                   const std::string& args)
+{
+    if(olCompile::IsCacheDisabled())
+        return {};
+
+    (void)num_cu;
+    auto f = GetCacheFile(target.DbId(), name, args);
+    if(boost::filesystem::exists(f))
+    {
+        return f.string();
+    }
+    else
+    {
+        return {};
+    }
+}
+
+void SaveBinary(const boost::filesystem::path& binary_path,
+                const TargetProperties& target,
+                const std::string& name,
+                const std::string& args)
+{
+    if(olCompile::IsCacheDisabled())
+    {
+        boost::filesystem::remove(binary_path);
+    }
+    else
+    {
+        auto p = GetCacheFile(target.DbId(), name, args);
+        boost::filesystem::create_directories(p.parent_path());
+        boost::filesystem::rename(binary_path, p);
+    }
+}
+
+} // namespace olCompile

driver/olCompiling/hip_utility/exec_utils.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * 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 <exec_utils.hpp>
+#include <manage_ptr.hpp>
+#include <istream>
+#include <ostream>
+#include <string>
+#include <cstdio>
+#include <array>
+#include <cassert>
+
+#ifdef __linux__
+#include <unistd.h>
+#include <cstdio>
+#include <sys/wait.h>
+#endif // __linux__
+
+namespace olCompile {
+namespace exec {
+
+int Run(const std::string& p, std::istream* in, std::ostream* out)
+{
+#ifdef __linux__
+    const auto redirect_stdin  = (in != nullptr);
+    const auto redirect_stdout = (out != nullptr);
+
+    assert(!(redirect_stdin && redirect_stdout));
+
+    const auto file_mode = redirect_stdout ? "r" : "w";
+    OLC_MANAGE_PTR(FILE*, pclose) pipe{popen(p.c_str(), file_mode)};
+
+    if(!pipe)
+        throw std::runtime_error("olCompile::exec::Run(): popen(" + p + ", " + file_mode +
+                                 ") failed");
+
+    if(redirect_stdin || redirect_stdout)
+    {
+        std::array<char, 1024> buffer{};
+
+        if(redirect_stdout)
+        {
+            while(feof(pipe.get()) == 0)
+                if(fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
+                    *out << buffer.data();
+        }
+        else
+        {
+            while(!in->eof())
+            {
+                in->read(buffer.data(), buffer.size() - 1);
+                buffer[in->gcount()] = 0;
+
+                if(fputs(buffer.data(), pipe.get()) == EOF)
+                    throw std::runtime_error("olCompile::exec::Run(): fputs() failed");
+            }
+        }
+    }
+
+    auto status = pclose(pipe.release());
+    return WEXITSTATUS(status);
+#else
+    (void)p;
+    (void)in;
+    (void)out;
+    return -1;
+#endif // __linux__
+}
+
+} // namespace exec
+} // namespace olCompile

driver/olCompiling/hip_utility/handlehip.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017-2020 Advanced Micro Devices, Inc.
+ *
+ * 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 <handle.hpp>
+
+#include <binary_cache.hpp>
+#include <env.hpp>
+#include <kernel_cache.hpp>
+#include <stringutils.hpp>
+#include <target_properties.hpp>
+
+#include <hipCheck.hpp>
+
+#include <write_file.hpp>
+
+#include <boost/filesystem.hpp>
+#include <boost/lexical_cast.hpp>
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <thread>
+
+OLC_DECLARE_ENV_VAR(OLC_DEVICE_CU)
+
+namespace olCompile {
+
+std::size_t GetAvailableMemory()
+{
+    size_t free, total;
+    MY_HIP_CHECK(hipMemGetInfo(&free, &total));
+    return free;
+}
+
+int get_device_id() // Get random device
+{
+    int device;
+
+    MY_HIP_CHECK(hipGetDevice(&device));
+
+    return device;
+}
+
+void set_device(int id) { MY_HIP_CHECK(hipSetDevice(id)); }
+
+int set_default_device()
+{
+    int n;
+
+    MY_HIP_CHECK(hipGetDeviceCount(&n));
+
+    // Pick device based on process id
+    auto pid = ::getpid();
+    assert(pid > 0);
+    set_device(pid % n);
+    return (pid % n);
+}
+
+struct HandleImpl
+{
+    using StreamPtr = std::shared_ptr<typename std::remove_pointer<hipStream_t>::type>;
+
+    HandleImpl() {}
+
+    StreamPtr create_stream()
+    {
+        hipStream_t result;
+
+        MY_HIP_CHECK(hipStreamCreate(&result));
+
+        return StreamPtr{result, &hipStreamDestroy};
+    }
+
+    static StreamPtr reference_stream(hipStream_t s) { return StreamPtr{s, null_deleter{}}; }
+
+    std::string get_device_name() const
+    {
+        hipDeviceProp_t props;
+
+        MY_HIP_CHECK(hipGetDeviceProperties(&props, device));
+
+        const std::string name(props.gcnArchName);
+        return name;
+    }
+
+    StreamPtr stream = nullptr;
+    int device       = -1;
+    KernelCache cache;
+    TargetProperties target_properties;
+};
+
+Handle::Handle(hipStream_t stream) : impl(new HandleImpl())
+{
+    this->impl->device = get_device_id();
+
+    if(stream == nullptr)
+        this->impl->stream = HandleImpl::reference_stream(nullptr);
+    else
+        this->impl->stream = HandleImpl::reference_stream(stream);
+
+    this->impl->target_properties.Init(this);
+}
+
+Handle::Handle() : impl(new HandleImpl())
+{
+    this->impl->device = get_device_id();
+    this->impl->stream = HandleImpl::reference_stream(nullptr);
+
+    this->impl->target_properties.Init(this);
+}
+
+Handle::~Handle() {}
+
+void Handle::SetStream(hipStream_t streamID) const
+{
+    this->impl->stream = HandleImpl::reference_stream(streamID);
+
+    this->impl->target_properties.Init(this);
+}
+
+hipStream_t Handle::GetStream() const { return impl->stream.get(); }
+
+KernelInvoke Handle::AddKernel(const std::string& algorithm,
+                               const std::string& network_config,
+                               const std::string& program_name,
+                               const std::string& kernel_name,
+                               const std::vector<size_t>& vld,
+                               const std::vector<size_t>& vgd,
+                               const std::string& params,
+                               std::size_t cache_index) const
+{
+
+    auto obj = this->impl->cache.AddKernel(
+        *this, algorithm, network_config, program_name, kernel_name, vld, vgd, params, cache_index);
+    return this->Run(obj);
+}
+
+void Handle::ClearKernels(const std::string& algorithm, const std::string& network_config) const
+{
+    this->impl->cache.ClearKernels(algorithm, network_config);
+}
+
+const std::vector<Kernel>& Handle::GetKernelsImpl(const std::string& algorithm,
+                                                  const std::string& network_config) const
+{
+    return this->impl->cache.GetKernels(algorithm, network_config);
+}
+
+bool Handle::HasKernel(const std::string& algorithm, const std::string& network_config) const
+{
+    return this->impl->cache.HasKernels(algorithm, network_config);
+}
+
+KernelInvoke Handle::Run(Kernel k) const { return k.Invoke(this->GetStream()); }
+
+Program Handle::LoadProgram(const std::string& program_name, std::string params) const
+{
+    if((!olCompile::EndsWith(program_name, ".mlir-cpp")) &&
+       (!olCompile::EndsWith(program_name, ".mlir")))
+    {
+        params += " -mcpu=" + this->GetTargetProperties().Name();
+    }
+
+    auto hsaco = olCompile::LoadBinary(
+        this->GetTargetProperties(), this->GetMaxComputeUnits(), program_name, params);
+    if(hsaco.empty())
+    {
+        auto p = HIPOCProgram{program_name, params, this->GetTargetProperties()};
+
+        auto path = olCompile::GetCachePath() / boost::filesystem::unique_path();
+        if(p.IsCodeObjectInMemory())
+            olCompile::WriteFile(p.GetCodeObjectBlob(), path);
+        else
+            boost::filesystem::copy_file(p.GetCodeObjectPathname(), path);
+        olCompile::SaveBinary(path, this->GetTargetProperties(), program_name, params);
+
+        return p;
+    }
+    else
+    {
+        return HIPOCProgram{program_name, hsaco};
+    }
+}
+
+bool Handle::HasProgram(const std::string& program_name, const std::string& params) const
+{
+    return this->impl->cache.HasProgram(program_name, params);
+}
+
+void Handle::AddProgram(Program prog,
+                        const std::string& program_name,
+                        const std::string& params) const
+{
+    this->impl->cache.AddProgram(prog, program_name, params);
+}
+
+void Handle::Finish() const { MY_HIP_CHECK(hipStreamSynchronize(this->GetStream())); }
+
+std::size_t Handle::GetLocalMemorySize() const
+{
+    int result;
+
+    MY_HIP_CHECK(hipDeviceGetAttribute(
+        &result, hipDeviceAttributeMaxSharedMemoryPerBlock, this->impl->device));
+
+    return result;
+}
+
+std::size_t Handle::GetGlobalMemorySize() const
+{
+    size_t result;
+
+    MY_HIP_CHECK(hipDeviceTotalMem(&result, this->impl->device));
+
+    return result;
+}
+
+std::size_t Handle::GetMaxComputeUnits() const
+{
+    int result;
+    const char* const num_cu = olCompile::GetStringEnv(OLC_DEVICE_CU{});
+    if(num_cu != nullptr && strlen(num_cu) > 0)
+    {
+        return boost::lexical_cast<std::size_t>(num_cu);
+    }
+
+    MY_HIP_CHECK(
+        hipDeviceGetAttribute(&result, hipDeviceAttributeMultiprocessorCount, this->impl->device));
+
+    return result;
+}
+
+std::size_t Handle::GetWavefrontWidth() const
+{
+    hipDeviceProp_t props{};
+
+    MY_HIP_CHECK(hipGetDeviceProperties(&props, this->impl->device));
+
+    auto result = static_cast<size_t>(props.warpSize);
+    return result;
+}
+
+std::string Handle::GetDeviceNameImpl() const { return this->impl->get_device_name(); }
+
+std::string Handle::GetDeviceName() const { return this->impl->target_properties.Name(); }
+
+const TargetProperties& Handle::GetTargetProperties() const
+{
+    return this->impl->target_properties;
+}
+
+std::ostream& Handle::Print(std::ostream& os) const
+{
+    os << "stream: " << this->impl->stream << ", device_id: " << this->impl->device;
+    return os;
+}
+
+} // namespace olCompile

driver/olCompiling/hip_utility/hip_build_utils.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * 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 <hip_build_utils.hpp>
+#include <stringutils.hpp>
+#include <tmp_dir.hpp>
+#include <env.hpp>
+#include <target_properties.hpp>
+#include <write_file.hpp>
+#include <exec_utils.hpp>
+#include <logger.hpp>
+#include <config.h>
+#include <boost/optional.hpp>
+#include <sstream>
+#include <string>
+#include <stdexcept>
+
+#include <iostream>
+
+OLC_DECLARE_ENV_VAR(OLC_DEBUG_HIP_VERBOSE)
+OLC_DECLARE_ENV_VAR(OLC_DEBUG_HIP_DUMP)
+
+#define OLC_HIP_COMPILER "/opt/rocm/llvm/bin/clang++"
+
+namespace olCompile {
+
+bool IsHccCompiler()
+{
+    static const auto isHcc = EndsWith(OLC_HIP_COMPILER, "hcc");
+    return isHcc;
+}
+
+bool IsHipClangCompiler()
+{
+    static const auto isClangXX = EndsWith(OLC_HIP_COMPILER, "clang++");
+    return isClangXX;
+}
+
+namespace {
+
+inline bool ProduceCoV3()
+{
+    // Otherwise, let's enable CO v3 for HIP kernels since ROCm 3.0.
+    return (HipCompilerVersion() >= external_tool_version_t{3, 0, -1});
+}
+
+/// Returns option for enabling/disabling CO v3 generation for the compiler
+/// that builds HIP kernels, depending on compiler version etc.
+inline const std::string& GetCoV3Option(const bool enable)
+{
+    /// \note PR #2166 uses the "--hcc-cov3" option when isHCC is true.
+    /// It's unclear why... HCC included in ROCm 2.8 does not support it,
+    /// perhaps it suits for some older HCC?
+    ///
+    /// These options are Ok for ROCm 3.0:
+    static const std::string option_enable{"-mcode-object-v3"};
+    static const std::string no_option{};
+    if(enable)
+        return option_enable;
+    else
+        return no_option;
+}
+} // namespace
+
+static boost::filesystem::path HipBuildImpl(boost::optional<TmpDir>& tmp_dir,
+                                            const std::string& filename,
+                                            std::string src,
+                                            std::string params,
+                                            const TargetProperties& target,
+                                            const bool testing_mode,
+                                            const bool sources_already_reside_on_filesystem)
+{
+#ifdef __linux__
+    // Write out the include files
+    // Let's assume includes are overkill for feature tests & optimize'em out.
+    if(!testing_mode)
+    {
+        auto inc_list = GetHipKernelIncList();
+        auto inc_path = tmp_dir->path;
+        boost::filesystem::create_directories(inc_path);
+        for(auto inc_file : inc_list)
+        {
+            auto inc_src = GetKernelInc(inc_file);
+            WriteFile(inc_src, inc_path / inc_file);
+        }
+    }
+
+    // Sources produced by MLIR-cpp already reside in tmp dir.
+    if(!sources_already_reside_on_filesystem)
+    {
+        src += "\nint main() {}\n";
+        WriteFile(src, tmp_dir->path / filename);
+    }
+
+    // cppcheck-suppress unreadVariable
+    const LcOptionTargetStrings lots(target);
+
+    auto env = std::string("");
+    if(IsHccCompiler())
+    {
+        params += " -amdgpu-target=" + target.Name();
+        params += " " + GetCoV3Option(ProduceCoV3());
+    }
+    else if(IsHipClangCompiler())
+    {
+        if(params.find("-std=") == std::string::npos)
+            params += " --std=c++11";
+
+        if(HipCompilerVersion() < external_tool_version_t{4, 1, 0})
+            params += " --cuda-gpu-arch=" + lots.device;
+        else
+            params += " --cuda-gpu-arch=" + lots.device + lots.xnack;
+
+        params += " --cuda-device-only";
+        params += " -c";
+        params += " -O3 ";
+    }
+
+    params += " -Wno-unused-command-line-argument -I. ";
+    params += OLC_STRINGIZE(HIP_COMPILER_FLAGS);
+    if(IsHccCompiler())
+    {
+        env += std::string("KMOPTLLC=\"-mattr=+enable-ds128 ");
+        if(HipCompilerVersion() >= external_tool_version_t{2, 8, 0})
+            env += " --amdgpu-spill-vgpr-to-agpr=0";
+        env += '\"';
+    }
+    else if(IsHipClangCompiler())
+    {
+        params += " -mllvm --amdgpu-spill-vgpr-to-agpr=0";
+        params += " -mllvm -amdgpu-early-inline-all=true";
+        params += " -mllvm -amdgpu-function-calls=false";
+    }
+
+    if(olCompile::IsEnabled(OLC_DEBUG_HIP_VERBOSE{}))
+    {
+        params += " -v";
+    }
+
+    if(olCompile::IsEnabled(OLC_DEBUG_HIP_DUMP{}))
+    {
+        if(IsHccCompiler())
+        {
+            params += " -gline-tables-only";
+            env += " KMDUMPISA=1";
+            env += " KMDUMPLLVM=1";
+        }
+        else if(IsHipClangCompiler())
+        {
+            params += " -gline-tables-only";
+            params += " -save-temps";
+        }
+    }
+
+    // hip version
+    params +=
+        std::string(" -DHIP_PACKAGE_VERSION_FLAT=") + std::to_string(HIP_PACKAGE_VERSION_FLAT);
+
+    params += " ";
+    auto bin_file = tmp_dir->path / (filename + ".o");
+
+    // compile
+    const std::string redirector = testing_mode ? " 1>/dev/null 2>&1" : "";
+    tmp_dir->Execute(env + std::string(" ") + OLC_HIP_COMPILER,
+                     params + filename + " -o " + bin_file.string() + redirector);
+    if(!boost::filesystem::exists(bin_file))
+        throw std::runtime_error(filename + " failed to compile");
+#ifdef EXTRACTKERNEL_BIN
+    if(IsHccCompiler())
+    {
+        // call extract kernel
+        tmp_dir->Execute(EXTRACTKERNEL_BIN, " -i " + bin_file.string());
+        auto hsaco =
+            std::find_if(boost::filesystem::directory_iterator{tmp_dir->path}, {}, [](auto entry) {
+                return (entry.path().extension() == ".hsaco");
+            });
+
+        if(hsaco == boost::filesystem::directory_iterator{})
+        {
+            fdt_log(LogLevel::Info, "HipBuild", "failed to find *.hsaco in ")
+                << hsaco->path().string() << std::endl;
+        }
+
+        return hsaco->path();
+    }
+#endif
+    return bin_file;
+#else
+    (void)filename;
+    (void)params;
+    throw std::runtimer_error("HIP kernels are only supported in Linux");
+#endif
+}
+
+boost::filesystem::path HipBuild(boost::optional<TmpDir>& tmp_dir,
+                                 const std::string& filename,
+                                 std::string src,
+                                 std::string params,
+                                 const TargetProperties& target,
+                                 const bool sources_already_reside_on_filesystem)
+{
+    return HipBuildImpl(
+        tmp_dir, filename, src, params, target, false, sources_already_reside_on_filesystem);
+}
+
+void bin_file_to_str(const boost::filesystem::path& file, std::string& buf)
+{
+    std::ifstream bin_file_ptr(file.string().c_str(), std::ios::binary);
+    std::ostringstream bin_file_strm;
+    bin_file_strm << bin_file_ptr.rdbuf();
+    buf = bin_file_strm.str();
+}
+
+static external_tool_version_t HipCompilerVersionImpl()
+{
+    external_tool_version_t version;
+    if(IsHccCompiler())
+    {
+        const std::string path(OLC_HIP_COMPILER);
+        const std::string mandatory_prefix("(based on HCC ");
+        do
+        {
+            if(path.empty() || !std::ifstream(path).good())
+                break;
+
+            std::stringstream out;
+            if(olCompile::exec::Run(path + " --version", nullptr, &out) != 0)
+                break;
+
+            std::string line;
+            while(!out.eof())
+            {
+                std::getline(out, line);
+                fdt_log() << line;
+                auto begin = line.find(mandatory_prefix);
+                if(begin == std::string::npos)
+                    continue;
+
+                begin += mandatory_prefix.size();
+                int v3, v2, v1 = v2 = v3 = -1;
+                char c2, c1 = c2 = 'X';
+                std::istringstream iss(line.substr(begin));
+                iss >> v1 >> c1 >> v2 >> c2 >> v3;
+                if(!iss.fail() && v1 >= 0)
+                {
+                    version.major = v1;
+                    if(c1 == '.' && v2 >= 0)
+                    {
+                        version.minor = v2;
+                        if(c2 == '.' && v3 >= 0)
+                            version.patch = v3;
+                    }
+                }
+                break;
+            }
+        } while(false);
+    }
+    else
+    {
+#ifdef HIP_PACKAGE_VERSION_MAJOR
+        fdt_log(
+            LogLevel::Info, "HipCompilerVersion", "Read version information from HIP package...");
+        version.major = HIP_PACKAGE_VERSION_MAJOR;
+#ifdef HIP_PACKAGE_VERSION_MINOR
+        version.minor = HIP_PACKAGE_VERSION_MINOR;
+#else
+        version.minor = 0;
+#endif
+#ifdef HIP_PACKAGE_VERSION_PATCH
+        version.patch = HIP_PACKAGE_VERSION_PATCH;
+#else
+        version.patch = 0;
+#endif
+#else // HIP_PACKAGE_VERSION_MAJOR is not defined. CMake failed to find HIP package.
+        fdt_log(LogLevel::Info, "HipCompilerVersion", "...assuming 3.2.0 (hip-clang RC)");
+        version.major = 3;
+        version.minor = 2;
+        version.patch = 0;
+#endif
+    }
+    fdt_log() << version.major << '.' << version.minor << '.' << version.patch << std::endl;
+    return version;
+}
+
+external_tool_version_t HipCompilerVersion()
+{
+    // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+    static auto once = HipCompilerVersionImpl();
+    return once;
+}
+
+bool operator>(const external_tool_version_t& lhs, const external_tool_version_t& rhs)
+{
+    if(lhs.major > rhs.major)
+        return true;
+    else if(lhs.major == rhs.major)
+    {
+        if(lhs.minor > rhs.minor)
+            return true;
+        else if(lhs.minor == rhs.minor)
+            return (lhs.patch > rhs.patch);
+        else
+            return false;
+    }
+    else
+        return false;
+}
+
+bool operator<(const external_tool_version_t& lhs, const external_tool_version_t& rhs)
+{
+    return rhs > lhs;
+}
+bool operator>=(const external_tool_version_t& lhs, const external_tool_version_t& rhs)
+{
+    return !(lhs < rhs);
+}
+
+bool operator<=(const external_tool_version_t& lhs, const external_tool_version_t& rhs)
+{
+    return !(lhs > rhs);
+}
+
+} // namespace olCompile

driver/olCompiling/hip_utility/hipoc_kernel.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Advanced Micro Devices, Inc.
+ *
+ * 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 <env.hpp>
+#include <hipoc_kernel.hpp>
+#include <hipCheck.hpp>
+
+#include <hip/hip_ext.h>
+#include <hip/hip_runtime.h>
+
+#include <chrono>
+#include <thread>
+
+namespace olCompile {
+
+void HIPOCKernelInvoke::run(void* args, std::size_t size) const
+{
+    HipEventPtr start = nullptr;
+    HipEventPtr stop  = nullptr;
+    void* config[]    = {// HIP_LAUNCH_PARAM_* are macros that do horrible things
+                      // NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
+                      HIP_LAUNCH_PARAM_BUFFER_POINTER,
+                      args,
+                      // NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
+                      HIP_LAUNCH_PARAM_BUFFER_SIZE,
+                      &size,
+                      // NOLINTNEXTLINE cppcoreguidelines-pro-type-cstyle-cast
+                      HIP_LAUNCH_PARAM_END};
+    if(callback)
+    {
+        start = make_hip_event();
+        stop  = make_hip_event();
+    }
+
+    MY_HIP_CHECK(hipExtModuleLaunchKernel(fun,
+                                          gdims[0],
+                                          gdims[1],
+                                          gdims[2],
+                                          ldims[0],
+                                          ldims[1],
+                                          ldims[2],
+                                          0,
+                                          stream,
+                                          nullptr,
+                                          reinterpret_cast<void**>(&config),
+                                          start.get(),
+                                          stop.get()));
+
+    if(callback)
+    {
+        MY_HIP_CHECK(hipEventSynchronize(stop.get()));
+        callback(start.get(), stop.get());
+    }
+}
+
+HIPOCKernelInvoke HIPOCKernel::Invoke(hipStream_t stream,
+                                      std::function<void(hipEvent_t, hipEvent_t)> callback) const
+{
+    return HIPOCKernelInvoke{stream, fun, ldims, gdims, name, callback};
+}
+} // namespace olCompile

driver/olCompiling/hip_utility/hipoc_program.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Advanced Micro Devices, Inc.
+ *
+ * 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 <hip_build_utils.hpp>
+#include <hipoc_program.hpp>
+#include <kernel.hpp>
+#include <stringutils.hpp>
+#include <target_properties.hpp>
+#include <env.hpp>
+#include <write_file.hpp>
+#include <boost/optional.hpp>
+#include <boost/filesystem/operations.hpp>
+
+#include <cstring>
+#include <mutex>
+#include <sstream>
+
+#include <unistd.h>
+
+namespace olCompile {
+
+static hipModulePtr CreateModule(const boost::filesystem::path& hsaco_file)
+{
+    hipModule_t raw_m;
+    MY_HIP_CHECK(hipModuleLoad(&raw_m, hsaco_file.string().c_str()));
+    hipModulePtr m{raw_m};
+    return m;
+}
+
+template <typename T> /// intended for std::string and std::vector<char>
+hipModulePtr CreateModuleInMem(const T& blob)
+{
+    hipModule_t raw_m;
+    MY_HIP_CHECK(hipModuleLoadData(&raw_m, reinterpret_cast<const void*>(blob.data())));
+    hipModulePtr m{raw_m};
+    return m;
+}
+
+HIPOCProgramImpl::HIPOCProgramImpl(const std::string& program_name,
+                                   const boost::filesystem::path& filespec)
+    : program(program_name), hsaco_file(filespec)
+{
+    this->module = CreateModule(hsaco_file);
+}
+
+HIPOCProgramImpl::HIPOCProgramImpl(const std::string& program_name,
+                                   std::string params,
+                                   const TargetProperties& target_)
+    : program(program_name), target(target_)
+{
+    BuildCodeObject(params);
+    if(!binary.empty())
+    {
+        module = CreateModuleInMem(this->binary);
+    }
+    else
+    {
+        module = CreateModule(this->hsaco_file);
+    }
+}
+
+void HIPOCProgramImpl::BuildCodeObjectInFile(std::string& params,
+                                             const std::string& src,
+                                             const std::string& filename)
+{
+
+    this->dir.emplace(filename);
+    hsaco_file = dir->path / (filename + ".o");
+
+    if(olCompile::EndsWith(filename, ".cpp"))
+    {
+        hsaco_file = HipBuild(dir, filename, src, params, target);
+    }
+    else
+        throw std::runtime_error("Only HIP kernel source of .cpp file is supported");
+
+    if(!boost::filesystem::exists(hsaco_file))
+        throw std::runtime_error("Cant find file: " + hsaco_file.string());
+}
+
+void HIPOCProgramImpl::BuildCodeObject(std::string params)
+{
+    std::string filename = program;
+
+    if(olCompile::EndsWith(filename, ".cpp"))
+    {
+        params += " -Wno-everything";
+    }
+
+    BuildCodeObjectInFile(params, GetKernelSrc(this->program), filename);
+}
+
+HIPOCProgram::HIPOCProgram() {}
+HIPOCProgram::HIPOCProgram(const std::string& program_name,
+                           std::string params,
+                           const TargetProperties& target)
+    : impl(std::make_shared<HIPOCProgramImpl>(program_name, params, target))
+{
+}
+
+HIPOCProgram::HIPOCProgram(const std::string& program_name, const boost::filesystem::path& hsaco)
+    : impl(std::make_shared<HIPOCProgramImpl>(program_name, hsaco))
+{
+}
+
+hipModule_t HIPOCProgram::GetModule() const { return impl->module.get(); }
+
+boost::filesystem::path HIPOCProgram::GetCodeObjectPathname() const { return impl->hsaco_file; }
+
+std::string HIPOCProgram::GetCodeObjectBlob() const
+{
+    return {impl->binary.data(), impl->binary.size()};
+}
+
+bool HIPOCProgram::IsCodeObjectInMemory() const { return !impl->binary.empty(); };
+
+} // namespace olCompile

driver/olCompiling/hip_utility/kernel_build_params.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2019 Advanced Micro Devices, Inc.
+ *
+ * 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 <sstream>
+
+#include <boost/range/adaptor/transformed.hpp>
+
+#include <kernel_build_params.hpp>
+#include <stringutils.hpp>
+
+namespace olCompile {
+
+static std::string GenerateDefines(const std::vector<KernelBuildParameter>& options,
+                                   const std::string& prefix)
+{
+    const auto strs =
+        options | boost::adaptors::transformed([&prefix](const KernelBuildParameter& define) {
+            std::ostringstream ss;
+
+            ss << '-';
+            if(define.type == ParameterTypes::Define)
+                ss << prefix;
+
+            ss << define.name;
+
+            if(!define.value.empty())
+            {
+                switch(define.type)
+                {
+                case ParameterTypes::Define: ss << '='; break;
+                case ParameterTypes::Option: ss << ' '; break;
+                }
+
+                ss << define.value;
+            }
+
+            return ss.str();
+        });
+
+    return JoinStrings(strs, " ");
+}
+
+} // namespace olCompile

driver/olCompiling/hip_utility/kernel_cache.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Advanced Micro Devices, Inc.
+ *
+ * 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.
+ *
+ *******************************************************************************/
+/* ************************************************************************
+ * Copyright 2015 Vratis, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ************************************************************************ */
+
+#include <env.hpp>
+#include <kernel_cache.hpp>
+#include <stringutils.hpp>
+
+#include <iostream>
+#include <iterator>
+
+namespace olCompile {
+
+const std::vector<Kernel>& KernelCache::GetKernels(const std::string& algorithm,
+                                                   const std::string& network_config)
+{
+
+    std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
+
+    const auto it = kernel_map.find(key);
+    if(it != kernel_map.end())
+    {
+        return it->second;
+    }
+
+    static const std::vector<Kernel> empty{};
+    return empty;
+}
+
+bool KernelCache::HasKernels(const std::string& algorithm, const std::string& network_config) const
+{
+    const auto key = std::make_pair(algorithm, network_config);
+    const auto it  = kernel_map.find(key);
+    if(it == kernel_map.end())
+        return false;
+
+    if(it->second.empty())
+    {
+        throw std::runtime_error(
+            "There should be at least one kernel in kernel cache if an entry exists");
+    }
+
+    return true;
+}
+
+bool KernelCache::HasProgram(const std::string& name, const std::string& params) const
+{
+    const auto key = std::make_pair(name, params);
+    return program_map.count(key) > 0;
+}
+
+void KernelCache::AddProgram(Program prog, const std::string& program_name, std::string params)
+{
+    program_map[std::make_pair(program_name, params)] = prog;
+}
+
+Kernel KernelCache::AddKernel(const Handle& h,
+                              const std::string& algorithm,
+                              const std::string& network_config,
+                              const std::string& program_name,
+                              const std::string& kernel_name,
+                              const std::vector<size_t>& vld,
+                              const std::vector<size_t>& vgd,
+                              std::string params,
+                              std::size_t cache_index)
+{
+    const std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
+
+    Program program;
+
+    auto program_it = program_map.find(std::make_pair(program_name, params));
+    if(program_it != program_map.end())
+    {
+        program = program_it->second;
+    }
+    else
+    {
+        program                                           = h.LoadProgram(program_name, params);
+        program_map[std::make_pair(program_name, params)] = program;
+    }
+
+    Kernel kernel{};
+
+    kernel = Kernel{program, kernel_name, vld, vgd};
+
+    if(!network_config.empty() && !algorithm.empty())
+    {
+        this->AddKernel(key, kernel, cache_index);
+    }
+    return kernel;
+}
+
+void KernelCache::AddKernel(Key key, Kernel k, std::size_t cache_index)
+{
+    auto&& v = kernel_map[key];
+    if(cache_index >= v.size())
+    {
+        v.resize(cache_index + 1);
+    }
+    v[cache_index] = k;
+}
+
+void KernelCache::ClearKernels(const std::string& algorithm, const std::string& network_config)
+{
+    if(network_config.empty() || algorithm.empty())
+    {
+        throw std::runtime_error("Network config or algorithm empty.");
+    }
+    const std::pair<std::string, std::string> key = std::make_pair(algorithm, network_config);
+    auto&& v                                      = this->kernel_map[key];
+    if(!v.empty())
+    {
+    }
+    v.clear();
+}
+
+KernelCache::KernelCache() {}
+
+} // namespace olCompile

driver/olCompiling/hip_utility/logger.cpp

+#include <config.h>
+#include <logger.hpp>
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+namespace olCompile {
+
+#if OLC_DEBUG
+static LogLevel defLevel = LogLevel::Info2;
+#else
+static LogLevel defLevel = LogLevel::Error;
+#endif
+
+string LogLevelString(LogLevel level)
+{
+    switch(level)
+    {
+    case LogLevel::Error: return ("Error");
+    case LogLevel::Warning: return ("Warning");
+    case LogLevel::Info: return ("Info");
+    case LogLevel::Info2: return ("Info2");
+    default: return ("Unknown");
+    };
+};
+
+ostream& fdt_log(LogLevel level, const char* header, const char* content)
+{
+    if(level > olCompile::defLevel)
+    {
+        return (cerr);
+    };
+
+    cerr << endl << LogLevelString(level) << ":" << header << ", " << content;
+
+    return (cerr);
+}
+
+ostream& fdt_log() { return (cerr); };
+
+void fdt_log_flush() { cerr << endl; }
+};

driver/olCompiling/hip_utility/md5.cpp

+/*
+ * Derived from a public-domain MD5 implementation. Original license
+ * below.
+ *
+ * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
+ * MD5 Message-Digest Algorithm (RFC 1321).
+ *
+ * Homepage:
+ * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
+ *
+ * Author:
+ * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
+ *
+ * This software was written by Alexander Peslyak in 2001.  No copyright is
+ * claimed, and the software is hereby placed in the public domain.
+ * In case this attempt to disclaim copyright and place the software in the
+ * public domain is deemed null and void, then the software is
+ * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
+ * general public under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted.
+ *
+ * There's ABSOLUTELY NO WARRANTY, express or implied.
+ *
+ * (This is a heavily cut-down "BSD license".)
+ *
+ * This differs from Colin Plumb's older public domain implementation in that
+ * no exactly 32-bit integer data type is required (any 32-bit or wider
+ * unsigned integer data type will do), there's no compile-time endianness
+ * configuration, and the function prototypes match OpenSSL's.  No code from
+ * Colin Plumb's implementation has been reused; this comment merely compares
+ * the properties of the two independent implementations.
+ *
+ * The primary goals of this implementation are portability and ease of use.
+ * It is meant to be fast, but not as fast as possible.  Some known
+ * optimizations are not included to reduce source code size and avoid
+ * compile-time configuration.
+ */
+#include <md5.hpp>
+#include <array>
+#include <cstring>
+#include <cstdint>
+#include <sstream>
+#include <iomanip>
+
+#define MD5_DIGEST_LENGTH 16
+
+struct MD5_CTX
+{
+    uint32_t lo, hi;
+    uint32_t a, b, c, d;
+    unsigned char buffer[64];
+    uint32_t block[MD5_DIGEST_LENGTH];
+};
+
+/*
+ * The basic MD5 functions.
+ *
+ * F and G are optimized compared to their RFC 1321 definitions for
+ * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
+ * implementation.
+ */
+#define F(x, y, z) ((z) ^ ((x) & ((y) ^ (z))))
+#define G(x, y, z) ((y) ^ ((z) & ((x) ^ (y))))
+#define H(x, y, z) (((x) ^ (y)) ^ (z))
+#define H2(x, y, z) ((x) ^ ((y) ^ (z)))
+#define I(x, y, z) ((y) ^ ((x) | ~(z)))
+
+/*
+ * The MD5 transformation for all four rounds.
+ */
+#define STEP(f, a, b, c, d, x, t, s)                         \
+    (a) += f((b), (c), (d)) + (x) + (t);                     \
+    (a) = (((a) << (s)) | (((a)&0xffffffff) >> (32 - (s)))); \
+    (a) += (b);
+
+/*
+ * SET reads 4 input bytes in little-endian byte order and stores them in a
+ * properly aligned word in host byte order.
+ *
+ * The check for little-endian architectures that tolerate unaligned memory
+ * accesses is just an optimization.  Nothing will break if it fails to detect
+ * a suitable architecture.
+ *
+ * Unfortunately, this optimization may be a C strict aliasing rules violation
+ * if the caller's data buffer has effective type that cannot be aliased by
+ * uint32_t.  In practice, this problem may occur if these MD5 routines are
+ * inlined into a calling function, or with future and dangerously advanced
+ * link-time optimizations.  For the time being, keeping these MD5 routines in
+ * their own translation unit avoids the problem.
+ */
+#if defined(__i386__) || defined(__x86_64__) || defined(__vax__)
+#define SET(n) (*reinterpret_cast<const uint32_t*>(&ptr[(n)*4]))
+#define GET(n) SET(n)
+#else
+#define SET(n)                                                         \
+    (ctx->block[(n)] = static_cast<uint32_t>(ptr[(n)*4]) |             \
+                       (static_cast<uint32_t>(ptr[(n)*4 + 1]) << 8) |  \
+                       (static_cast<uint32_t>(ptr[(n)*4 + 2]) << 16) | \
+                       (static_cast<uint32_t>(ptr[(n)*4 + 3]) << 24))
+#define GET(n) (ctx->block[(n)])
+#endif
+
+/*
+ * This processes one or more 64-byte data blocks, but does NOT update the bit
+ * counters.  There are no alignment requirements.
+ */
+static const void* body(MD5_CTX* ctx, const void* data, size_t size)
+{
+    const unsigned char* ptr;
+    uint32_t a, b, c, d;
+
+    ptr = static_cast<const unsigned char*>(data);
+
+    a = ctx->a;
+    b = ctx->b;
+    c = ctx->c;
+    d = ctx->d;
+
+    do
+    {
+        uint32_t saved_a = a, saved_b = b, saved_c = c, saved_d = d;
+
+        /* Round 1 */
+        STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
+        STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
+        STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
+        STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
+        STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
+        STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
+        STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
+        STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
+        STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
+        STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
+        STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
+        STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
+        STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
+        STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
+        STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
+        STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
+
+        /* Round 2 */
+        STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
+        STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
+        STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
+        STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
+        STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
+        STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
+        STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
+        STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
+        STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
+        STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
+        STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
+        STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
+        STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
+        STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
+        STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
+        STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
+
+        /* Round 3 */
+        STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
+        STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
+        STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
+        STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
+        STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
+        STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
+        STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
+        STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
+        STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
+        STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
+        STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
+        STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
+        STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
+        STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
+        STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
+        STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
+
+        /* Round 4 */
+        STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
+        STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
+        STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
+        STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
+        STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
+        STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
+        STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
+        STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
+        STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
+        STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
+        STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
+        STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
+        STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
+        STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
+        STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
+        STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
+
+        a += saved_a;
+        b += saved_b;
+        c += saved_c;
+        d += saved_d;
+
+        ptr += 64;
+    } while((size -= 64) != 0u);
+
+    ctx->a = a;
+    ctx->b = b;
+    ctx->c = c;
+    ctx->d = d;
+
+    return ptr;
+}
+
+static void MD5_Init(MD5_CTX* ctx)
+{
+    ctx->a = 0x67452301;
+    ctx->b = 0xefcdab89;
+    ctx->c = 0x98badcfe;
+    ctx->d = 0x10325476;
+
+    ctx->lo = 0;
+    ctx->hi = 0;
+}
+
+static void MD5_Update(MD5_CTX* ctx, const void* data, size_t size)
+{
+    uint32_t saved_lo;
+    size_t used;
+
+    saved_lo = ctx->lo;
+    if((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
+        ctx->hi++;
+    ctx->hi += size >> 29;
+
+    used = saved_lo & 0x3f;
+
+    if(used != 0u)
+    {
+        size_t available = 64 - used;
+
+        if(size < available)
+        {
+            memcpy(&ctx->buffer[used], data, size);
+            return;
+        }
+
+        memcpy(&ctx->buffer[used], data, available);
+        data = static_cast<const unsigned char*>(data) + available;
+        size -= available;
+        body(ctx, ctx->buffer, 64);
+    }
+
+    if(size >= 64)
+    {
+        data = body(ctx, data, size & ~size_t{0x3f});
+        size &= 0x3f;
+    }
+
+    memcpy(ctx->buffer, data, size);
+}
+
+#define OUT(dst, src)                                   \
+    (dst)[0] = static_cast<unsigned char>(src);         \
+    (dst)[1] = static_cast<unsigned char>((src) >> 8);  \
+    (dst)[2] = static_cast<unsigned char>((src) >> 16); \
+    (dst)[3] = static_cast<unsigned char>((src) >> 24);
+
+static void MD5_Final(unsigned char* result, MD5_CTX* ctx)
+{
+    size_t used, available;
+
+    used = ctx->lo & 0x3f;
+
+    ctx->buffer[used++] = 0x80;
+
+    available = 64 - used;
+
+    if(available < 8)
+    {
+        memset(&ctx->buffer[used], 0, available);
+        body(ctx, ctx->buffer, 64);
+        used      = 0;
+        available = 64;
+    }
+
+    memset(&ctx->buffer[used], 0, available - 8);
+
+    ctx->lo <<= 3;
+    OUT(&ctx->buffer[56], ctx->lo)
+    OUT(&ctx->buffer[60], ctx->hi)
+
+    body(ctx, ctx->buffer, 64);
+
+    OUT(&result[0], ctx->a)
+    OUT(&result[4], ctx->b)
+    OUT(&result[8], ctx->c)
+    OUT(&result[12], ctx->d)
+
+    memset(ctx, 0, sizeof(*ctx));
+}
+
+namespace olCompile {
+
+std::string md5(std::string s)
+{
+    std::array<unsigned char, MD5_DIGEST_LENGTH> result{};
+
+    MD5_CTX ctx{};
+    MD5_Init(&ctx);
+    MD5_Update(&ctx, s.data(), s.length());
+    MD5_Final(result.data(), &ctx);
+
+    std::ostringstream sout;
+    sout << std::hex << std::setfill('0');
+    for(auto c : result)
+        sout << std::setw(2) << int{c};
+
+    return sout.str();
+}
+} // namespace olCompile

driver/olCompiling/hip_utility/target_properties.cpp

+/*******************************************************************************
+ *
+ * MIT License
+ *
+ * Copyright (c) 2020 Advanced Micro Devices, Inc.
+ *
+ * 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 <env.hpp>
+#include <handle.hpp>
+#include <stringutils.hpp>
+#include <target_properties.hpp>
+#include <map>
+#include <string>
+
+OLC_DECLARE_ENV_VAR(OLC_DEBUG_ENFORCE_DEVICE)
+
+namespace olCompile {
+
+static std::string GetDeviceNameFromMap(const std::string& in)
+{
+    // NOLINTNEXTLINE (cppcoreguidelines-avoid-non-const-global-variables)
+    static std::map<std::string, std::string> device_name_map = {
+        {"Ellesmere", "gfx803"},
+        {"Baffin", "gfx803"},
+        {"RacerX", "gfx803"},
+        {"Polaris10", "gfx803"},
+        {"Polaris11", "gfx803"},
+        {"Tonga", "gfx803"},
+        {"Fiji", "gfx803"},
+        {"gfx800", "gfx803"},
+        {"gfx802", "gfx803"},
+        {"gfx804", "gfx803"},
+        {"Vega10", "gfx900"},
+        {"gfx901", "gfx900"},
+        {"10.3.0 Sienna_Cichlid 18", "gfx1030"},
+    };
+
+    const char* const p_asciz = olCompile::GetStringEnv(OLC_DEBUG_ENFORCE_DEVICE{});
+    if(p_asciz != nullptr && strlen(p_asciz) > 0)
+        return {p_asciz};
+
+    const auto name = in.substr(0, in.find(':')); // str.substr(0, npos) returns str.
+
+    auto match = device_name_map.find(name);
+    if(match != device_name_map.end())
+        return match->second;
+    return name; // NOLINT (performance-no-automatic-move)
+}
+
+void TargetProperties::Init(const Handle* const handle)
+{
+    const auto rawName = [&]() -> std::string { return handle->GetDeviceNameImpl(); }();
+    name               = GetDeviceNameFromMap(rawName);
+    // DKMS driver older than 5.9 may report incorrect state of SRAMECC feature.
+    // Therefore we compute default SRAMECC and rely on it for now.
+    sramecc = [&]() -> boost::optional<bool> {
+        if(name == "gfx906" || name == "gfx908")
+            return {true};
+        return {};
+    }();
+    // However we need to store the reported state, even if it is incorrect,
+    // to use together with COMGR.
+    sramecc_reported = [&]() -> boost::optional<bool> {
+        if(rawName.find(":sramecc+") != std::string::npos)
+            return true;
+        if(rawName.find(":sramecc-") != std::string::npos)
+            return false;
+        return sramecc; // default
+    }();
+    xnack = [&]() -> boost::optional<bool> {
+        if(rawName.find(":xnack+") != std::string::npos)
+            return true;
+        if(rawName.find(":xnack-") != std::string::npos)
+            return false;
+        return {}; // default
+    }();
+    InitDbId();
+}
+
+void TargetProperties::InitDbId()
+{
+    dbId = name;
+    if(name == "gfx906" || name == "gfx908")
+    {
+        // Let's stay compatible with existing gfx906/908 databases.
+        // When feature equal to the default (SRAMECC ON), do not
+        // append feature suffix. This is for backward compatibility
+        // with legacy databases ONLY!
+        if(!sramecc || !(*sramecc))
+            dbId += "_nosramecc";
+    }
+    else
+    {
+        if(sramecc && *sramecc)
+            dbId += "_sramecc";
+    }
+    if(xnack && *xnack)
+        dbId += "_xnack";
+}
+
+} // namespace olCompile