Multi-threaded file opening/mapping.

Author: johnno1962

lld/MachO/Driver.cpp

@@ -292,7 +292,7 @@ static void saveThinArchiveToRepro(ArchiveFile const *file) {
 struct DeferredFile {
   StringRef path;
   bool isLazy;
-  MemoryBufferRef buffer;
+  std::optional<MemoryBufferRef> buffer;
 };
 using DeferredFiles = std::vector<DeferredFile>;
 
@@ -346,8 +346,10 @@ void multiThreadedPageInBackground(DeferredFiles &deferred) {
   std::atomic_int numDeferedFilesAdvised = 0;
   auto t0 = high_resolution_clock::now();
 
-  auto preloadDeferredFile = [&](const DeferredFile &deferredFile) {
-    const StringRef &buff = deferredFile.buffer.getBuffer();
+  auto preloadDeferredFile = [&](DeferredFile &deferredFile) {
+    if (!deferredFile.buffer.has_value())
+      deferredFile.buffer = *readFile(deferredFile.path);
+    const StringRef &buff = (*deferredFile.buffer).getBuffer();
     if (buff.size() > largeArchive)
       return;
 
@@ -394,12 +396,9 @@ void multiThreadedPageInBackground(DeferredFiles &deferred) {
                  << duration_cast<milliseconds>(dt).count() / 1000. << "\n";
 }
 
-static void multiThreadedPageIn(const DeferredFiles &deferred) {
+static void multiThreadedPageIn(DeferredFiles &deferred) {
   static SerialBackgroundQueue pageInQueue;
-  pageInQueue.queueWork([=]() {
-    DeferredFiles files = deferred;
-    multiThreadedPageInBackground(files);
-  });
+  pageInQueue.queueWork([&]() { multiThreadedPageInBackground(deferred); });
 }
 
 static InputFile *processFile(std::optional<MemoryBufferRef> buffer,
@@ -574,13 +573,12 @@ static InputFile *addFile(StringRef path, LoadType loadType,
 }
 
 static void deferFile(StringRef path, bool isLazy, DeferredFiles &deferred) {
+  if (config->readWorkers)
+    return deferred.push_back({path, isLazy, std::nullopt});
   std::optional<MemoryBufferRef> buffer = readFile(path);
   if (!buffer)
     return;
-  if (config->readWorkers)
-    deferred.push_back({path, isLazy, *buffer});
-  else
-    processFile(buffer, nullptr, path, LoadType::CommandLine, isLazy);
+  processFile(buffer, nullptr, path, LoadType::CommandLine, isLazy);
 }
 
 static std::vector<StringRef> missingAutolinkWarnings;
@@ -1365,7 +1363,8 @@ static void createFiles(const InputArgList &args) {
   bool isLazy = false;
   // If we've processed an opening --start-lib, without a matching --end-lib
   bool inLib = false;
-  DeferredFiles deferredFiles;
+  static DeferredFiles deferredFiles;
+  deferredFiles.clear();
 
   for (const Arg *arg : args) {
     const Option &opt = arg->getOption();
@@ -1444,9 +1443,13 @@ static void createFiles(const InputArgList &args) {
   if (config->readWorkers) {
     multiThreadedPageIn(deferredFiles);
 
-    DeferredFiles archiveContents;
+    static DeferredFiles archiveContents;
     std::vector<ArchiveFile *> archives;
+    archiveContents.clear();
+
     for (auto &file : deferredFiles) {
+      if (!file.buffer.has_value())
+        file.buffer = readFile(file.path);
       auto inputFile = processFile(file.buffer, &archiveContents, file.path,
                                    LoadType::CommandLine, file.isLazy);
       if (ArchiveFile *archive = dyn_cast<ArchiveFile>(inputFile))

lld/MachO/InputFiles.cpp

@@ -212,10 +212,15 @@ static bool compatWithTargetArch(const InputFile *file, const Header *hdr) {
 DenseMap<CachedHashStringRef, MemoryBufferRef> macho::cachedReads;
 // Open a given file path and return it as a memory-mapped file.
 std::optional<MemoryBufferRef> macho::readFile(StringRef path) {
+  static std::mutex mutex;
+  mutex.lock();
   CachedHashStringRef key(path);
   auto entry = cachedReads.find(key);
-  if (entry != cachedReads.end())
+  if (entry != cachedReads.end()) {
+    mutex.unlock();
     return entry->second;
+  }
+  mutex.unlock();
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
       MemoryBuffer::getFile(path, false, /*RequiresNullTerminator=*/false);
@@ -224,18 +229,23 @@ std::optional<MemoryBufferRef> macho::readFile(StringRef path) {
     return std::nullopt;
   }
 
+  mutex.lock();
   std::unique_ptr<MemoryBuffer> &mb = *mbOrErr;
   MemoryBufferRef mbref = mb->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(mb)); // take mb ownership
+  mutex.unlock();
 
   // If this is a regular non-fat file, return it.
   const char *buf = mbref.getBufferStart();
   const auto *hdr = reinterpret_cast<const fat_header *>(buf);
   if (mbref.getBufferSize() < sizeof(uint32_t) ||
       read32be(&hdr->magic) != FAT_MAGIC) {
+    mutex.lock();
     if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
-    return cachedReads[key] = mbref;
+    cachedReads[key] = mbref;
+    mutex.unlock();
+    return mbref;
   }
 
   llvm::BumpPtrAllocator &bAlloc = lld::bAlloc();
@@ -272,10 +282,13 @@ std::optional<MemoryBufferRef> macho::readFile(StringRef path) {
     uint32_t size = read32be(&arch[i].size);
     if (offset + size > mbref.getBufferSize())
       error(path + ": slice extends beyond end of file");
+    mutex.lock();
     if (tar)
       tar->append(relativeToRoot(path), mbref.getBuffer());
-    return cachedReads[key] = MemoryBufferRef(StringRef(buf + offset, size),
-                                              path.copy(bAlloc));
+    mbref = MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
+    cachedReads[key] = mbref;
+    mutex.unlock();
+    return mbref;
   }
 
   auto targetArchName = getArchName(target->cpuType, target->cpuSubtype);