Revert "Multi-threaded file opening/mapping."

This reverts commit be7af98.

Author: johnno1962

lld/MachO/Driver.cpp

@@ -292,7 +292,7 @@ static void saveThinArchiveToRepro(ArchiveFile const *file) {
 struct DeferredFile {
   StringRef path;
   bool isLazy;
-  std::optional<MemoryBufferRef> buffer;
+  MemoryBufferRef buffer;
 };
 using DeferredFiles = std::vector<DeferredFile>;
 
@@ -346,10 +346,8 @@ void multiThreadedPageInBackground(DeferredFiles &deferred) {
   std::atomic_int numDeferedFilesAdvised = 0;
   auto t0 = high_resolution_clock::now();
 
-  auto preloadDeferredFile = [&](DeferredFile &deferredFile) {
-    if (!deferredFile.buffer.has_value())
-      deferredFile.buffer = *readFile(deferredFile.path);
-    const StringRef &buff = (*deferredFile.buffer).getBuffer();
+  auto preloadDeferredFile = [&](const DeferredFile &deferredFile) {
+    const StringRef &buff = deferredFile.buffer.getBuffer();
     if (buff.size() > largeArchive)
       return;
 
@@ -396,9 +394,12 @@ void multiThreadedPageInBackground(DeferredFiles &deferred) {
                  << duration_cast<milliseconds>(dt).count() / 1000. << "\n";
 }
 
-static void multiThreadedPageIn(DeferredFiles &deferred) {
+static void multiThreadedPageIn(const DeferredFiles &deferred) {
   static SerialBackgroundQueue pageInQueue;
-  pageInQueue.queueWork([&]() { multiThreadedPageInBackground(deferred); });
+  pageInQueue.queueWork([=]() {
+    DeferredFiles files = deferred;
+    multiThreadedPageInBackground(files);
+  });
 }
 
 static InputFile *processFile(std::optional<MemoryBufferRef> buffer,
@@ -573,12 +574,13 @@ 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;
-  processFile(buffer, nullptr, path, LoadType::CommandLine, isLazy);
+  if (config->readWorkers)
+    deferred.push_back({path, isLazy, *buffer});
+  else
+    processFile(buffer, nullptr, path, LoadType::CommandLine, isLazy);
 }
 
 static std::vector<StringRef> missingAutolinkWarnings;
@@ -1363,8 +1365,7 @@ 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;
-  static DeferredFiles deferredFiles;
-  deferredFiles.clear();
+  DeferredFiles deferredFiles;
 
   for (const Arg *arg : args) {
     const Option &opt = arg->getOption();
@@ -1443,13 +1444,9 @@ static void createFiles(const InputArgList &args) {
   if (config->readWorkers) {
     multiThreadedPageIn(deferredFiles);
 
-    static DeferredFiles archiveContents;
+    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,15 +212,10 @@ 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()) {
-    mutex.unlock();
+  if (entry != cachedReads.end())
     return entry->second;
-  }
-  mutex.unlock();
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
       MemoryBuffer::getFile(path, false, /*RequiresNullTerminator=*/false);
@@ -229,23 +224,18 @@ 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());
-    cachedReads[key] = mbref;
-    mutex.unlock();
-    return mbref;
+    return cachedReads[key] = mbref;
   }
 
   llvm::BumpPtrAllocator &bAlloc = lld::bAlloc();
@@ -282,13 +272,10 @@ 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());
-    mbref = MemoryBufferRef(StringRef(buf + offset, size), path.copy(bAlloc));
-    cachedReads[key] = mbref;
-    mutex.unlock();
-    return mbref;
+    return cachedReads[key] = MemoryBufferRef(StringRef(buf + offset, size),
+                                              path.copy(bAlloc));
   }
 
   auto targetArchName = getArchName(target->cpuType, target->cpuSubtype);