[COMGR][Cache] Get an input-stable -cuid when compiling hip

When compiling hip, compute the hash of the input files contents use it
as the cuid.

Otherwise a cuid that is computed from the input file paths (which
depend on /tmp/comgr-xxxxx) is generated. This path changes at every run
which causes a cache miss since the command-line changes.

co-authored by anjenner and jmmartinez

Change-Id: I6cbd3248df9c6bb8ac440c7c80ca3cb1dbe6722c

Author: jmmartinez

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

@@ -76,31 +76,14 @@ void addString(CachedCommandAdaptor::HashAlgorithm &H, StringRef S) {
   H.update(S);
 }
 
-void addFileContents(CachedCommandAdaptor::HashAlgorithm &H, StringRef Buf) {
-  // this is a workaround temporary paths getting in the output files of the
-  // different commands in #line directives in preprocessed files, and the
-  // ModuleID or source_filename in the bitcode.
-  while (!Buf.empty()) {
-    std::optional<size_t> ComgrTmpPos = searchComgrTmpModel(Buf);
-    if (!ComgrTmpPos) {
-      addString(H, Buf);
-      break;
-    }
-
-    StringRef ToHash = Buf.substr(0, *ComgrTmpPos);
-    addString(H, ToHash);
-    Buf = Buf.substr(ToHash.size() + StringRef("comgr-xxxxxx").size());
-  }
-}
-
 Error addFile(CachedCommandAdaptor::HashAlgorithm &H, StringRef Path) {
   auto BufOrError = MemoryBuffer::getFile(Path);
   if (std::error_code EC = BufOrError.getError()) {
     return errorCodeToError(EC);
   }
   StringRef Buf = BufOrError.get()->getBuffer();
 
-  addFileContents(H, Buf);
+  CachedCommandAdaptor::addFileContents(H, Buf);
 
   return Error::success();
 }
@@ -150,6 +133,24 @@ bool isSourceCodeInput(const driver::InputInfo &II) {
 }
 } // namespace
 
+void CachedCommandAdaptor::addFileContents(
+    CachedCommandAdaptor::HashAlgorithm &H, StringRef Buf) {
+  // this is a workaround temporary paths getting in the output files of the
+  // different commands in #line directives in preprocessed files, and the
+  // ModuleID or source_filename in the bitcode.
+  while (!Buf.empty()) {
+    std::optional<size_t> ComgrTmpPos = searchComgrTmpModel(Buf);
+    if (!ComgrTmpPos) {
+      addString(H, Buf);
+      break;
+    }
+
+    StringRef ToHash = Buf.substr(0, *ComgrTmpPos);
+    addString(H, ToHash);
+    Buf = Buf.substr(ToHash.size() + StringRef("comgr-xxxxxx").size());
+  }
+}
+
 Expected<CachedCommandAdaptor::Identifier>
 CachedCommandAdaptor::getIdentifier() const {
   CachedCommandAdaptor::HashAlgorithm H;

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

@@ -71,6 +71,9 @@ class CachedCommandAdaptor {
 
   virtual ~CachedCommandAdaptor() = default;
 
+  // helper to work around the comgr-xxxxx string appearing in files
+  static void addFileContents(HashAlgorithm &H, llvm::StringRef Buf);
+
 protected:
   virtual ActionClass getClass() const = 0;
   virtual void addOptionsIdentifier(HashAlgorithm &) const = 0;

amd/comgr/src/comgr-compiler.cpp

@@ -55,6 +55,7 @@
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/FrontendTool/Utils.h"
+#include "llvm/ADT/StringExtras.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
@@ -721,6 +722,15 @@ amd_comgr_status_t executeCommand(const Command &Job, raw_ostream &LogS,
   return AMD_COMGR_STATUS_SUCCESS;
 }
 
+std::string getStableCUID(const DataSet *InSet) {
+  using Hash = CachedCommandAdaptor::HashAlgorithm;
+  Hash H;
+  for (const DataObject *Input : InSet->DataObjects) {
+    CachedCommandAdaptor::addFileContents(H,
+                                          StringRef{Input->Data, Input->Size});
+  }
+  return toHex(H.final());
+}
 } // namespace
 
 amd_comgr_status_t
@@ -1034,6 +1044,10 @@ amd_comgr_status_t AMDGPUCompiler::addCompilationFlags() {
   case AMD_COMGR_LANGUAGE_HIP:
     Args.push_back("hip");
     Args.push_back("--offload-device-only");
+    // Pass a cuid that depends on the input files
+    // Otherwise, a random (which depends on the /tmp/comgr-xxxxx path) cuid is
+    // generated which causes a cache miss on every run.
+    Args.push_back(Saver.save("-cuid=" + getStableCUID(InSet)).data());
     break;
   default:
     return AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT;