Merge pull request llvm#525 from AMD-Lightning-Internal/amd/dev/juamarti/reduced-cache-over-mainline-spirv

[Comgr][SPIRV][Cache] Support for caching of spirv converstion to bitcode

Author: jmmartinez

amd/comgr/CMakeLists.txt

@@ -83,6 +83,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/src/comgr-cache-command.cpp

@@ -68,14 +68,6 @@ bool hasDebugOrProfileInfo(ArrayRef<const char *> Args) {
   return false;
 }
 
-void addString(CachedCommandAdaptor::HashAlgorithm &H, StringRef S) {
-  // hash size + contents to avoid collisions
-  // for example, we have to ensure that the result of hashing "AA" "BB" is
-  // different from "A" "ABB"
-  H.update(S.size());
-  H.update(S);
-}
-
 Error addFile(CachedCommandAdaptor::HashAlgorithm &H, StringRef Path) {
   auto BufOrError = MemoryBuffer::getFile(Path);
   if (std::error_code EC = BufOrError.getError()) {
@@ -151,6 +143,15 @@ void CachedCommandAdaptor::addFileContents(
   }
 }
 
+void CachedCommandAdaptor::addString(CachedCommandAdaptor::HashAlgorithm &H,
+                                     StringRef S) {
+  // hash size + contents to avoid collisions
+  // for example, we have to ensure that the result of hashing "AA" "BB" is
+  // different from "A" "ABB"
+  H.update(S.size());
+  H.update(S);
+}
+
 Expected<CachedCommandAdaptor::Identifier>
 CachedCommandAdaptor::getIdentifier() const {
   CachedCommandAdaptor::HashAlgorithm H;
@@ -170,6 +171,41 @@ CachedCommandAdaptor::getIdentifier() const {
   return Id;
 }
 
+llvm::Error
+CachedCommandAdaptor::writeUniqueExecuteOutput(StringRef OutputFilename,
+                                               StringRef CachedBuffer) {
+  std::error_code EC;
+  raw_fd_ostream Out(OutputFilename, EC);
+  if (EC) {
+    Error E = createStringError(EC, Twine("Failed to open ") + OutputFilename +
+                                        " : " + EC.message() + "\n");
+    return E;
+  }
+
+  Out.write(CachedBuffer.data(), CachedBuffer.size());
+  Out.close();
+  if (Out.has_error()) {
+    Error E = createStringError(EC, Twine("Failed to write ") + OutputFilename +
+                                        " : " + EC.message() + "\n");
+    return E;
+  }
+
+  return Error::success();
+}
+
+Expected<std::unique_ptr<MemoryBuffer>>
+CachedCommandAdaptor::readUniqueExecuteOutput(StringRef OutputFilename) {
+  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
+      MemoryBuffer::getFile(OutputFilename);
+  if (!MBOrErr) {
+    std::error_code EC = MBOrErr.getError();
+    return createStringError(EC, Twine("Failed to open ") + OutputFilename +
+                                     " : " + EC.message() + "\n");
+  }
+
+  return std::move(*MBOrErr);
+}
+
 CachedCommand::CachedCommand(driver::Command &Command,
                              DiagnosticOptions &DiagOpts,
                              ExecuteFnTy &&ExecuteImpl)
@@ -249,35 +285,16 @@ bool CachedCommand::canCache() const {
 
 Error CachedCommand::writeExecuteOutput(StringRef CachedBuffer) {
   StringRef OutputFilename = Command.getOutputFilenames().front();
-  std::error_code EC;
-  raw_fd_ostream Out(OutputFilename, EC);
-  if (EC) {
-    Error E = createStringError(EC, Twine("Failed to open ") + OutputFilename +
-                                        " : " + EC.message() + "\n");
-    return E;
-  }
-
-  Out.write(CachedBuffer.data(), CachedBuffer.size());
-  Out.close();
-  if (Out.has_error()) {
-    Error E = createStringError(EC, Twine("Failed to write ") + OutputFilename +
-                                        " : " + EC.message() + "\n");
-    return E;
-  }
-
-  return Error::success();
+  return CachedCommandAdaptor::writeUniqueExecuteOutput(OutputFilename,
+                                                        CachedBuffer);
 }
 
 Expected<StringRef> CachedCommand::readExecuteOutput() {
-  StringRef OutputFilename = Command.getOutputFilenames().front();
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
-      MemoryBuffer::getFile(OutputFilename);
-  if (!MBOrErr) {
-    std::error_code EC = MBOrErr.getError();
-    return createStringError(EC, Twine("Failed to open ") + OutputFilename +
-                                     " : " + EC.message() + "\n");
-  }
-  Output = std::move(*MBOrErr);
+  auto MaybeBuffer = CachedCommandAdaptor::readUniqueExecuteOutput(
+      Command.getOutputFilenames().front());
+  if (!MaybeBuffer)
+    return MaybeBuffer.takeError();
+  Output = std::move(*MaybeBuffer);
   return Output->getBuffer();
 }
 

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

@@ -57,7 +57,8 @@ class raw_ostream;
 namespace COMGR {
 class CachedCommandAdaptor {
 public:
-  using ActionClass = clang::driver::Action::ActionClass;
+  using ActionClass =
+      std::underlying_type_t<clang::driver::Action::ActionClass>;
   using HashAlgorithm = llvm::SHA256;
   using Identifier = llvm::SmallString<64>;
 
@@ -72,6 +73,13 @@ class CachedCommandAdaptor {
 
   // helper to work around the comgr-xxxxx string appearing in files
   static void addFileContents(HashAlgorithm &H, llvm::StringRef Buf);
+  static void addString(HashAlgorithm &H, llvm::StringRef Buf);
+
+  // helper since several command types just write to a single output file
+  static llvm::Error writeUniqueExecuteOutput(llvm::StringRef OutputFilename,
+                                              llvm::StringRef CachedBuffer);
+  static llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
+  readUniqueExecuteOutput(llvm::StringRef OutputFilename);
 
 protected:
   virtual ActionClass getClass() const = 0;

amd/comgr/src/comgr-compiler.cpp

@@ -41,6 +41,7 @@
 #include "comgr-device-libs.h"
 #include "comgr-diagnostic-handler.h"
 #include "comgr-env.h"
+#include "comgr-spirv-command.h"
 #include "lld/Common/CommonLinkerContext.h"
 #include "lld/Common/Driver.h"
 #include "clang/Basic/Version.h"
@@ -85,10 +86,6 @@
 #include "llvm/Support/WithColor.h"
 #include "llvm/TargetParser/Host.h"
 
-#ifndef COMGR_DISABLE_SPIRV
-#include "LLVMSPIRVLib/LLVMSPIRVLib.h"
-#endif
-
 #include "time-stat/ts-interface.h"
 
 #include <csignal>
@@ -1903,10 +1900,7 @@ amd_comgr_status_t AMDGPUCompiler::translateSpirvToBitcode() {
     return Status;
   }
 
-  LLVMContext Context;
-  Context.setDiagnosticHandler(
-      std::make_unique<AMDGPUCompilerDiagnosticHandler>(this->LogS), true);
-
+  auto Cache = CommandCache::get(LogS);
   for (auto *Input : InSet->DataObjects) {
 
     if (env::shouldSaveTemps()) {
@@ -1919,28 +1913,19 @@ amd_comgr_status_t AMDGPUCompiler::translateSpirvToBitcode() {
       return AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT;
     }
 
-    // TODO: With C++23, we should investigate replacing with spanstream
-    // to avoid memory copies:
-    //  https://en.cppreference.com/w/cpp/io/basic_ispanstream
-    std::istringstream ISS(std::string(Input->Data, Input->Size));
-
-    llvm::Module *M;
-    std::string Err;
-
-    SPIRV::TranslatorOpts Opts;
-    Opts.enableAllExtensions();
-    Opts.setDesiredBIsRepresentation(SPIRV::BIsRepresentation::OpenCL20);
+    SmallString<0> OutBuf;
+    SPIRVCommand SPIRV(Input, OutBuf);
 
-    if (!llvm::readSpirv(Context, Opts, ISS, M, Err)) {
-      LogS << "Failed to load SPIR-V as LLVM Module: " << Err << '\n';
-      return AMD_COMGR_STATUS_ERROR;
+    amd_comgr_status_t Status;
+    if (!Cache) {
+      Status = SPIRV.execute(LogS);
+    } else {
+      Status = Cache->execute(SPIRV, LogS);
     }
 
-    SmallString<0> OutBuf;
-    BitcodeWriter Writer(OutBuf);
-    Writer.writeModule(*M, false, nullptr, false, nullptr);
-    Writer.writeSymtab();
-    Writer.writeStrtab();
+    if (Status) {
+      return Status;
+    }
 
     amd_comgr_data_t OutputT;
     if (auto Status = amd_comgr_create_data(AMD_COMGR_DATA_KIND_BC, &OutputT)) {

amd/comgr/src/comgr-spirv-command.cpp

@@ -0,0 +1,109 @@
+/*******************************************************************************
+ *
+ * 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-spirv-command.h"
+
+#ifndef COMGR_DISABLE_SPIRV
+#include "comgr-diagnostic-handler.h"
+
+#include <LLVMSPIRVLib/LLVMSPIRVLib.h>
+#include <llvm/Bitcode/BitcodeWriter.h>
+#include <llvm/IR/LLVMContext.h>
+
+#include <sstream>
+#endif
+
+namespace COMGR {
+using namespace llvm;
+Error SPIRVCommand::writeExecuteOutput(StringRef CachedBuffer) {
+  assert(OutputBuffer.empty());
+  OutputBuffer.reserve(CachedBuffer.size());
+  OutputBuffer.insert(OutputBuffer.end(), CachedBuffer.begin(),
+                      CachedBuffer.end());
+  return Error::success();
+}
+
+Expected<StringRef> SPIRVCommand::readExecuteOutput() {
+  return StringRef(OutputBuffer.data(), OutputBuffer.size());
+}
+
+amd_comgr_status_t SPIRVCommand::execute(raw_ostream &LogS) {
+#ifndef COMGR_DISABLE_SPIRV
+  LLVMContext Context;
+  Context.setDiagnosticHandler(
+      std::make_unique<AMDGPUCompilerDiagnosticHandler>(LogS), true);
+
+  // TODO: With C++23, we should investigate replacing with spanstream
+  // to avoid memory copies:
+  //  https://en.cppreference.com/w/cpp/io/basic_ispanstream
+  std::istringstream ISS(std::string(InputBuffer.data(), InputBuffer.size()));
+
+  Module *M;
+  std::string Err;
+
+  if (!readSpirv(Context, ISS, M, Err)) {
+    LogS << "Failed to load SPIR-V as LLVM Module: " << Err << '\n';
+    return AMD_COMGR_STATUS_ERROR;
+  }
+
+  BitcodeWriter Writer(OutputBuffer);
+  Writer.writeModule(*M, false, nullptr, false, nullptr);
+  Writer.writeSymtab();
+  Writer.writeStrtab();
+  return AMD_COMGR_STATUS_SUCCESS;
+#else
+  return AMD_COMGR_STATUS_ERROR;
+#endif
+}
+
+SPIRVCommand::ActionClass SPIRVCommand::getClass() const {
+  // return an action class that is not allocated to distinguish it from any
+  // clang action
+  return clang::driver::Action::ActionClass::JobClassLast + 1;
+}
+
+void SPIRVCommand::addOptionsIdentifier(HashAlgorithm &) const {
+  // do nothing, there are no options
+  return;
+}
+
+Error SPIRVCommand::addInputIdentifier(HashAlgorithm &H) const {
+  addString(H, InputBuffer);
+  return Error::success();
+}
+} // namespace COMGR

amd/comgr/src/comgr-spirv-command.h

@@ -0,0 +1,69 @@
+/*******************************************************************************
+ *
+ * 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.
+ *
+ ******************************************************************************/
+
+#ifndef COMGR_SPIRV_COMMAND_H
+#define COMGR_SPIRV_COMMAND_H
+
+#include "comgr-cache-command.h"
+#include "comgr.h"
+
+namespace COMGR {
+class SPIRVCommand : public CachedCommandAdaptor {
+public:
+  llvm::StringRef InputBuffer;
+  llvm::SmallVectorImpl<char> &OutputBuffer;
+
+public:
+  SPIRVCommand(DataObject *Input, llvm::SmallVectorImpl<char> &OutputBuffer)
+      : InputBuffer(Input->Data, Input->Size), OutputBuffer(OutputBuffer) {}
+
+  bool canCache() const final { return true; }
+  llvm::Error writeExecuteOutput(llvm::StringRef CachedBuffer) final;
+  llvm::Expected<llvm::StringRef> readExecuteOutput() final;
+  amd_comgr_status_t execute(llvm::raw_ostream &LogS) final;
+
+  ~SPIRVCommand() override = default;
+
+protected:
+  ActionClass getClass() const override;
+  void addOptionsIdentifier(HashAlgorithm &) const override;
+  llvm::Error addInputIdentifier(HashAlgorithm &) const override;
+};
+} // namespace COMGR
+
+#endif