Cache commits rebased for promotion mainline (llvm#907)

Author: Salinas, David

amd/comgr/CMakeLists.txt

@@ -71,6 +71,9 @@ option(COMGR_BUILD_SHARED_LIBS "Build the shared library"
        ${build_shared_libs_default})
 
 set(SOURCES
+  src/comgr-cache.cpp
+  src/comgr-cache-command.cpp
+  src/comgr-cache-bundler-command.cpp
   src/comgr-compiler.cpp
   src/comgr.cpp
   src/comgr-device-libs.cpp
@@ -81,6 +84,7 @@ set(SOURCES
   src/comgr-metadata.cpp
   src/comgr-objdump.cpp
   src/comgr-signal.cpp
+  src/comgr-spirv-command.cpp
   src/comgr-symbol.cpp
   src/comgr-symbolizer.cpp
   src/time-stat/time-stat.cpp)

amd/comgr/README.md

@@ -125,6 +125,26 @@ These include:
   certain runtime headers. If this is not set, it has a default value of
   "${ROCM_PATH}/llvm".
 
+Comgr utilizes a cache to preserve the results of compilations between executions.
+The cache's status (enabled/disabled), storage location for its results,
+and eviction policy can be manipulated through specific environment variables.
+If an issue arises during cache initialization, the execution will proceed with
+the cache turned off.
+
+By default, the cache is turned off, set the environment variable
+`AMD_COMGR_CACHE=1` to enable it. This may change in a future release.
+
+* `AMD_COMGR_CACHE`: When unset or set to 0, the cache is turned off.
+* `AMD_COMGR_CACHE_DIR`: When set to "", the cache is turned off. If assigned a
+  value, that value is used as the path for cache storage. By default, it is
+  directed to "$XDG_CACHE_HOME/comgr_cache" (which defaults to
+  "$USER/.cache/comgr_cache" on Linux, and "%LOCALAPPDATA%\cache\comgr_cache"
+  on Microsoft Windows).
+* `AMD_COMGR_CACHE_POLICY`: If assigned a value, the string is interpreted and
+  applied to the cache pruning policy. The cache is pruned only upon program
+  termination. The string format aligns with [Clang's ThinLTO cache pruning policy](https://clang.llvm.org/docs/ThinLTO.html#cache-pruning).
+  The default policy is set as: "prune_interval=1h:prune_expiration=0h:cache_size=75%:cache_size_bytes=30g:cache_size_files=0".
+
 Comgr also supports some environment variables to aid in debugging. These
 include:
 

amd/comgr/cmake/DeviceLibs.cmake

@@ -59,6 +59,7 @@ foreach(AMDGCN_LIB_TARGET ${AMD_DEVICE_LIBS_TARGETS})
   add_dependencies(amd_comgr ${AMDGCN_LIB_TARGET}_header)
 
   list(APPEND TARGETS_INCLUDES "#include \"${header}\"")
+  list(APPEND TARGETS_HEADERS "${INC_DIR}/${header}")
 endforeach()
 
 list(JOIN TARGETS_INCLUDES "\n" TARGETS_INCLUDES)
@@ -110,4 +111,17 @@ list(APPEND TARGETS_DEFS "#undef AMD_DEVICE_LIBS_FUNCTION")
 list(JOIN TARGETS_DEFS "\n" TARGETS_DEFS)
 file(GENERATE OUTPUT ${GEN_LIBRARY_DEFS_INC_FILE} CONTENT "${TARGETS_DEFS}")
 
+# compute the sha256 of the device libraries to detect changes and pass them to comgr (used by the cache)
+find_package(Python3 REQUIRED Interpreter)
+set(DEVICE_LIBS_ID_SCRIPT "${CMAKE_CURRENT_SOURCE_DIR}/cmake/device-libs-id.py")
+set(DEVICE_LIBS_ID_HEADER ${INC_DIR}/libraries_sha.inc)
+add_custom_command(OUTPUT ${DEVICE_LIBS_ID_HEADER}
+  COMMAND ${Python3_EXECUTABLE} ${DEVICE_LIBS_ID_SCRIPT} --varname DEVICE_LIBS_ID --output ${DEVICE_LIBS_ID_HEADER} ${TARGETS_HEADERS}
+  DEPENDS ${DEVICE_LIBS_ID_SCRIPT} ${TARGETS_HEADERS}
+    COMMENT "Generating ${INC_DIR}/libraries_sha.inc"
+)
+set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${INC_DIR}/libraries_sha.inc)
+add_custom_target(libraries_sha_header DEPENDS ${INC_DIR}/libraries_sha.inc)
+add_dependencies(amd_comgr libraries_sha_header)
+
 include_directories(${INC_DIR})

amd/comgr/cmake/device-libs-id.py

@@ -0,0 +1,20 @@
+from argparse import ArgumentParser
+from hashlib import sha256
+from functools import reduce
+
+if __name__ == "__main__":
+    parser = ArgumentParser(description='Generate id by computing a hash of the generated headers')
+    parser.add_argument("headers", nargs='+', help='List of headers to generate id from')
+    parser.add_argument("--varname", help='Name of the variable to generate', required=True)
+    parser.add_argument("--output", help='Name of the header to generate', required=True)
+
+    args = parser.parse_args()
+    args.headers.sort()
+    
+    hash = sha256()
+    for x in args.headers:
+        hash.update(open(x, 'rb').read())
+    digest_uchar = hash.digest()
+    digest_char = [e if e < 128 else e-256 for e in digest_uchar]
+    digest_elts = ", ".join(map(str, digest_char))
+    print(f"static const char {args.varname}[] = {{{digest_elts}, 0}};", file=open(args.output, 'w'))

amd/comgr/cmake/opencl_pch.cmake

@@ -50,3 +50,7 @@ endfunction()
 
 generate_pch(1.2)
 generate_pch(2.0)
+
+# hash the opencl header and pass the result to comgr compilation
+file(SHA256 ${OPENCL_C_H} OPENCL_C_SHA)
+list(APPEND AMD_COMGR_PRIVATE_COMPILE_DEFINITIONS "OPENCL_C_SHA=${OPENCL_C_SHA}")

amd/comgr/src/comgr-cache-bundler-command.cpp

@@ -0,0 +1,181 @@
+/*******************************************************************************
+ *
+ * University of Illinois/NCSA
+ * Open Source License
+ *
+ * Copyright (c) 2003-2017 University of Illinois at Urbana-Champaign.
+ * Modifications (c) 2018 Advanced Micro Devices, Inc.
+ * All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * with 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:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimers.
+ *
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimers in the
+ *       documentation and/or other materials provided with the distribution.
+ *
+ *     * Neither the names of the LLVM Team, University of Illinois at
+ *       Urbana-Champaign, nor the names of its contributors may be used to
+ *       endorse or promote products derived from this Software without specific
+ *       prior written permission.
+ *
+ * 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
+ * CONTRIBUTORS 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 WITH
+ * THE SOFTWARE.
+ *
+ ******************************************************************************/
+
+#include <comgr-cache-bundler-command.h>
+
+#include <clang/Driver/OffloadBundler.h>
+#include <llvm/BinaryFormat/Magic.h>
+
+namespace COMGR {
+using namespace llvm;
+using namespace clang;
+
+using SizeFieldType = uint32_t;
+
+bool UnbundleCommand::canCache() const {
+  // The header format for AR files is not the same as object files
+  if (Kind == AMD_COMGR_DATA_KIND_AR_BUNDLE)
+    return false;
+
+  StringRef InputFilename = Config.InputFileNames.front();
+  file_magic Magic;
+  if (identify_magic(InputFilename, Magic))
+    return false;
+
+  // Check the input file magic. Handle only compressed bundles
+  // It's not worth to cache other types of bundles
+  return Magic == file_magic::offload_bundle_compressed;
+}
+
+Error UnbundleCommand::writeExecuteOutput(StringRef CachedBuffer) {
+  for (StringRef OutputFilename : Config.OutputFileNames) {
+    SizeFieldType OutputFileSize;
+    if (CachedBuffer.size() < sizeof(OutputFileSize))
+      return createStringError(std::errc::invalid_argument,
+                               "Not enough bytes to read output file size");
+    memcpy(&OutputFileSize, CachedBuffer.data(), sizeof(OutputFileSize));
+    CachedBuffer = CachedBuffer.drop_front(sizeof(OutputFileSize));
+
+    if (CachedBuffer.size() < OutputFileSize)
+      return createStringError(std::errc::invalid_argument,
+                               "Not enough bytes to read output file contents");
+
+    StringRef OutputFileContents = CachedBuffer.substr(0, OutputFileSize);
+    CachedBuffer = CachedBuffer.drop_front(OutputFileSize);
+
+    if (Error Err = CachedCommandAdaptor::writeUniqueExecuteOutput(
+            OutputFilename, OutputFileContents))
+      return Err;
+  }
+
+  if (!CachedBuffer.empty())
+    return createStringError(std::errc::invalid_argument,
+                             "Bytes in cache entry not used for the output");
+  return Error::success();
+}
+
+Expected<StringRef> UnbundleCommand::readExecuteOutput() {
+  size_t OutputSize = 0;
+  for (StringRef OutputFilename : Config.OutputFileNames) {
+    auto MaybeOneOutput =
+        CachedCommandAdaptor::readUniqueExecuteOutput(OutputFilename);
+    if (!MaybeOneOutput)
+      return MaybeOneOutput.takeError();
+
+    const MemoryBuffer &OneOutputBuffer = **MaybeOneOutput;
+    SizeFieldType OneOutputFileSize = OneOutputBuffer.getBufferSize();
+
+    OutputBuffer.resize_for_overwrite(OutputSize + sizeof(OneOutputFileSize) +
+                                      OneOutputFileSize);
+
+    memcpy(OutputBuffer.data() + OutputSize, &OneOutputFileSize,
+           sizeof(OneOutputFileSize));
+    OutputSize += sizeof(OneOutputFileSize);
+    memcpy(OutputBuffer.data() + OutputSize, OneOutputBuffer.getBufferStart(),
+           OneOutputFileSize);
+    OutputSize += OneOutputFileSize;
+  }
+  return OutputBuffer;
+}
+
+amd_comgr_status_t UnbundleCommand::execute(raw_ostream &LogS) {
+  assert(Config.InputFileNames.size() == 1);
+
+  OffloadBundler Bundler(Config);
+
+  switch (Kind) {
+  case AMD_COMGR_DATA_KIND_BC_BUNDLE:
+  case AMD_COMGR_DATA_KIND_OBJ_BUNDLE: {
+    if (Error Err = Bundler.UnbundleFiles()) {
+      logAllUnhandledErrors(std::move(Err), LogS, "Unbundle Error: ");
+      return AMD_COMGR_STATUS_ERROR;
+    }
+    break;
+  }
+  case AMD_COMGR_DATA_KIND_AR_BUNDLE: {
+    if (Error Err = Bundler.UnbundleArchive()) {
+      logAllUnhandledErrors(std::move(Err), LogS, "Unbundle Archives Error: ");
+      return AMD_COMGR_STATUS_ERROR;
+    }
+    break;
+  }
+  default:
+    llvm_unreachable("invalid bundle type");
+  }
+
+  return AMD_COMGR_STATUS_SUCCESS;
+}
+
+CachedCommandAdaptor::ActionClass UnbundleCommand::getClass() const {
+  return clang::driver::Action::OffloadUnbundlingJobClass;
+}
+
+void UnbundleCommand::addOptionsIdentifier(HashAlgorithm &H) const {
+  H.update(Config.TargetNames.size());
+  for (StringRef Target : Config.TargetNames) {
+    CachedCommandAdaptor::addString(H, Target);
+  }
+}
+
+Error UnbundleCommand::addInputIdentifier(HashAlgorithm &H) const {
+  StringRef InputFilename = Config.InputFileNames.front();
+
+  constexpr size_t LargestHeaderSize = CompressedOffloadBundle::V3HeaderSize;
+
+  ErrorOr<std::unique_ptr<MemoryBuffer>> MaybeInputBuffer =
+      MemoryBuffer::getFileSlice(InputFilename, LargestHeaderSize, 0);
+  if (!MaybeInputBuffer) {
+    std::error_code EC = MaybeInputBuffer.getError();
+    return createStringError(EC, Twine("Failed to open ") + InputFilename +
+                                     " : " + EC.message() + "\n");
+  }
+
+  MemoryBuffer &InputBuffer = **MaybeInputBuffer;
+
+  uint8_t Header[LargestHeaderSize];
+  memset(Header, 0, sizeof(Header));
+  memcpy(Header, InputBuffer.getBufferStart(),
+         std::min(LargestHeaderSize, InputBuffer.getBufferSize()));
+
+  // only hash the input file, not the whole header. Colissions are unlikely
+  // since the header includes a hash (weak) of the contents
+  H.update(Header);
+  return Error::success();
+}
+
+} // namespace COMGR

amd/comgr/src/comgr-cache-bundler-command.h

@@ -0,0 +1,74 @@
+/*******************************************************************************
+ *
+ * University of Illinois/NCSA
+ * Open Source License
+ *
+ * Copyright (c) 2018 Advanced Micro Devices, Inc. All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * with 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:
+ *
+ *     * Redistributions of source code must retain the above copyright notice,
+ *       this list of conditions and the following disclaimers.
+ *
+ *     * Redistributions in binary form must reproduce the above copyright
+ *       notice, this list of conditions and the following disclaimers in the
+ *       documentation and/or other materials provided with the distribution.
+ *
+ *     * Neither the names of Advanced Micro Devices, Inc. nor the names of its
+ *       contributors may be used to endorse or promote products derived from
+ *       this Software without specific prior written permission.
+ *
+ * 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
+ * CONTRIBUTORS 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 WITH
+ * THE SOFTWARE.
+ *
+ ******************************************************************************/
+
+#ifndef COMGR_CACHE_BUNDLER_COMMAND_H
+#define COMGR_CACHE_BUNDLER_COMMAND_H
+
+#include <comgr-cache-command.h>
+
+namespace clang {
+class OffloadBundlerConfig;
+} // namespace clang
+
+namespace COMGR {
+class UnbundleCommand final : public CachedCommandAdaptor {
+private:
+  amd_comgr_data_kind_t Kind;
+  const clang::OffloadBundlerConfig &Config;
+
+  // To avoid copies, store the output of execute, such that readExecuteOutput
+  // can return a reference.
+  llvm::SmallString<64> OutputBuffer;
+
+public:
+  UnbundleCommand(amd_comgr_data_kind_t Kind,
+                  const clang::OffloadBundlerConfig &Config)
+      : Kind(Kind), Config(Config) {}
+
+  bool canCache() const override;
+  llvm::Error writeExecuteOutput(llvm::StringRef CachedBuffer) override;
+  llvm::Expected<llvm::StringRef> readExecuteOutput() override;
+  amd_comgr_status_t execute(llvm::raw_ostream &LogS) override;
+
+  ~UnbundleCommand() override = default;
+
+protected:
+  ActionClass getClass() const override;
+  void addOptionsIdentifier(HashAlgorithm &) const override;
+  llvm::Error addInputIdentifier(HashAlgorithm &) const override;
+};
+} // namespace COMGR
+
+#endif