[ThinLTO] Move loading of cache entry to client

[tejohnson]

Summary

Have the cache pass back the path to the cache entry when it
is ready to be loaded, instead of a buffer.

For gold-plugin we can simply pass this file back to gold directly,
which avoids expensive writing of a separate tmp file. Ensure
the cache entry is not deleted on cleanup by adjusting the setting
of the IsTemporary flags.

Moved the loading of the buffer into llvm-lto2 to maintain current
behavior.

[mehdi_amini]

LGTM, thanks.

[mehdi_amini]

llvm/trunk/include/llvm/LTO/Caching.h

25

(I thought I commented inline when approving the revision, but didn't get through apparently)

Any reason not to use StringRef?
Or a const ref at minima?

llvm/trunk/include/llvm/LTO/Caching.h

 
 #include "llvm/ADT/SmallString.h"
 #include "llvm/LTO/Config.h"
 #include "llvm/Support/MemoryBuffer.h"
 
 namespace llvm {
 namespace lto {
 /// Type for client-supplied callback when a buffer is loaded from the cache.
-typedef std::function<void(std::unique_ptr<MemoryBuffer>)> AddBufferFn;
+typedef std::function<void(std::string)> AddBufferFn;
 
 /// Manage caching on the filesystem.
 ///
 /// The general scheme is the following:
 ///
 /// void do_stuff(AddBufferFn CallBack) {
 ///   /* ... */
 ///   {

 class CacheObjectOutput : public NativeObjectOutput {
   /// Path to the on-disk cache directory
   StringRef CacheDirectoryPath;
   /// Path to this entry in the cache, initialized by tryLoadFromCache().
   SmallString<128> EntryPath;
   /// Path to temporary file used to buffer output that will be committed to the
   /// cache entry when this object is destroyed
   SmallString<128> TempFilename;
-  /// User-supplied callback, called when the buffer is pulled out of the cache
+  /// User-supplied callback, used to provide path to cache entry
   /// (potentially after creating it).
   AddBufferFn AddBuffer;
 
 public:
   /// The destructor pulls the entry from the cache and calls the AddBuffer
   /// callback, after committing the entry into the cache on miss.
   ~CacheObjectOutput();
 
   /// Create a CacheObjectOutput: the client is supposed to create it in the
   /// callback supplied to LTO::run. The \p CacheDirectoryPath points to the
   /// directory on disk where to store the cache, and \p AddBuffer will be
-  /// called when the buffer is pulled out of the cache (potentially after
-  /// creating it).
+  /// called when the buffer is ready to be pulled out of the cache
+  /// (potentially after creating it).
   CacheObjectOutput(StringRef CacheDirectoryPath, AddBufferFn AddBuffer)
       : CacheDirectoryPath(CacheDirectoryPath), AddBuffer(AddBuffer) {}
 
   /// Return an allocated stream for the output, or null in case of failure.
   std::unique_ptr<raw_pwrite_stream> getStream() override;
 
   /// Set EntryPath, try loading from a possible cache first, return true on
   /// cache hit.

llvm/trunk/lib/LTO/Caching.cpp

CacheObjectOutput::~CacheObjectOutput() {
   if (!TempFilename.empty()) {
     if (EntryPath == CacheDirectoryPath)
       // The Key supplied to tryLoadFromCache was empty, do not commit the temp.
       EntryPath = TempFilename;
     else
       // We commit the tempfile into the cache now, by moving it to EntryPath.
       commitEntry(TempFilename, EntryPath);
   }
-  // Load the entry from the cache now.
-  auto ReloadedBufferOrErr = MemoryBuffer::getFile(EntryPath);
-  if (auto EC = ReloadedBufferOrErr.getError())
-    report_fatal_error(Twine("Can't reload cached file '") + EntryPath + "': " +
-                       EC.message() + "\n");
-
-  // Supply the resulting buffer to the user.
-  AddBuffer(std::move(*ReloadedBufferOrErr));
+  // Supply the cache path to the user.
+  AddBuffer(EntryPath.str());
 }
 
 // Return an allocated stream for the output, or null in case of failure.
 std::unique_ptr<raw_pwrite_stream> CacheObjectOutput::getStream() {
   assert(!EntryPath.empty() && "API Violation: client didn't call "
                                "tryLoadFromCache() before getStream()");
   // Write to a temporary to avoid race condition
   int TempFD;

llvm/trunk/tools/gold/gold-plugin.cpp

static ld_plugin_status allSymbolsReadHook() {
   std::vector<uintptr_t> IsTemporary(MaxTasks);
   std::vector<SmallString<128>> Filenames(MaxTasks);
 
   auto AddOutput =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectOutput> {
     auto &OutputName = Filenames[Task];
     getOutputFileName(Filename, /*TempOutFile=*/!SaveTemps, OutputName,
                       MaxTasks > 1 ? Task : -1);
-    IsTemporary[Task] = !SaveTemps;
+    IsTemporary[Task] = !SaveTemps && options::cache_dir.empty();
     if (options::cache_dir.empty())
       return llvm::make_unique<LTOOutput>(OutputName);
 
     return llvm::make_unique<CacheObjectOutput>(
-        options::cache_dir, [OutputName](std::unique_ptr<MemoryBuffer> Buffer) {
-          *LTOOutput(OutputName).getStream() << Buffer->getBuffer();
-        });
+        options::cache_dir,
+        [&OutputName](std::string EntryPath) { OutputName = EntryPath; });
   };
 
   check(Lto->run(AddOutput));
 
   if (options::TheOutputType == options::OT_DISABLE ||
       options::TheOutputType == options::OT_BC_ONLY)
     return LDPS_OK;
 

llvm/trunk/tools/llvm-lto2/llvm-lto2.cpp

int main(int argc, char **argv) {
 
   auto AddOutput =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectOutput> {
     std::string Path = OutputFilename + "." + utostr(Task);
     if (CacheDir.empty())
       return llvm::make_unique<LTOOutput>(std::move(Path));
 
     return llvm::make_unique<CacheObjectOutput>(
-        CacheDir, [Path](std::unique_ptr<MemoryBuffer> Buffer) {
-          *LTOOutput(Path).getStream() << Buffer->getBuffer();
+        CacheDir, [Path](std::string EntryPath) {
+          // Load the entry from the cache now.
+          auto ReloadedBufferOrErr = MemoryBuffer::getFile(EntryPath);
+          if (auto EC = ReloadedBufferOrErr.getError())
+            report_fatal_error(Twine("Can't reload cached file '") + EntryPath +
+                               "': " + EC.message() + "\n");
+
+          *LTOOutput(Path).getStream() << (*ReloadedBufferOrErr)->getBuffer();
         });
   };
 
   check(Lto.run(AddOutput), "LTO::run failed");
 }