Read public symbol names for LazyObjectFiles in parallel.

[ruiu]

Summary

This is in the context of https://reviews.llvm.org/D32867 and attempts
to speed up reading symbols from object files in archive files.

Interestingly, archives without symbol tables are faster than those
with symbol tables with this patch. I benchmarked the linker with
the default build configuration, stripped symbol tables from archives
in the build tree, and ran the same test again. The first attempt
to link clang took 8.17s (average of 10 trials using the perf
command). The second attempt took 8.04s. This is odd but seems real.

Somewhat orthogonal to this patch, but that result seems to imply
that there's room for improvements in the code to handle archive
symbol table.

[ruiu]

• Removed unrelated changes.

[ruiu]

I think the testcase is the same. Probably that's due to difference of machines. My workstation is beefy -- 2-socket Xeon with 10 physical cores each. What's your machine and your numbers?

lld/ELF/Driver.cpp

if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
       if (Value.getAsInteger(0, Result))
         error("invalid " + Key + ": " + Value);
       return Result;
     }
   }
   return Default;
 }
 
+// We need to call readSymbols() on each LazyObjectFile to let it
+// construct per-file internal data structure. Do that in parallel.
+static void readLazyObjects(ArrayRef<InputFile *> Files) {
+  std::vector<LazyObjectFile *> V;
+  for (InputFile *F : Files)
+    if (auto *Lazy = dyn_cast<LazyObjectFile>(F))
+      V.push_back(Lazy);
+
+  parallelForEach(V.begin(), V.end(),
+                  [](LazyObjectFile *F) { F->readSymbols(); });
+}
+
 void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Interpret this flag early because error() depends on them.
   Config->ErrorLimit = getInteger(Args, OPT_error_limit, 20);
 
   // Handle -help
void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   }
 
   readConfigs(Args);
   initLLVM(Args);
   createFiles(Args);
   inferMachineType();
   setConfigs();
   checkOptions(Args);
+  readLazyObjects(Files);
   if (ErrorCount)
     return;
 
   switch (Config->EKind) {
   case ELF32LEKind:
     link<ELF32LE>(Args);
     return;
   case ELF32BEKind:

lld/ELF/InputFiles.h

 public:
   explicit LazyObjectFile(MemoryBufferRef M) : InputFile(LazyObjectKind, M) {}
 
   static bool classof(const InputFile *F) {
     return F->kind() == LazyObjectKind;
   }
 
   template <class ELFT> void parse();
+  void readSymbols();
   MemoryBufferRef getBuffer();
   InputFile *fetch();
 
 private:
   std::vector<StringRef> getSymbols();
   template <class ELFT> std::vector<StringRef> getElfSymbols();
   std::vector<StringRef> getBitcodeSymbols();
 
+  llvm::Optional<std::vector<StringRef>> Symbols;
   bool Seen = false;
+  llvm::BumpPtrAllocator Alloc;
 };
 
 // An ArchiveFile object represents a .a file.
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(std::unique_ptr<Archive> &&File);
   static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
   template <class ELFT> void parse();

lld/ELF/InputFiles.cpp

 
 InputFile *LazyObjectFile::fetch() {
   MemoryBufferRef MBRef = getBuffer();
   if (MBRef.getBuffer().empty())
     return nullptr;
   return createObjectFile(MBRef);
 }
 
+void LazyObjectFile::readSymbols() { Symbols = getSymbols(); }
+
 template <class ELFT> void LazyObjectFile::parse() {
-  for (StringRef Sym : getSymbols())
+  assert(Symbols.hasValue());
+  for (StringRef Sym : *Symbols)
     Symtab<ELFT>::X->addLazyObject(Sym, *this);
 }
 
 template <class ELFT> std::vector<StringRef> LazyObjectFile::getElfSymbols() {
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::SymRange Elf_Sym_Range;
 
for (const Elf_Shdr &Sec : Sections) {
     return V;
   }
   return {};
 }
 
 std::vector<StringRef> LazyObjectFile::getBitcodeSymbols() {
   std::unique_ptr<lto::InputFile> Obj =
       check(lto::InputFile::create(this->MB), toString(this));
+
+  // Since this function is called inside parallel_for,
+  // we want to use a per-object allocator.
+  StringSaver Saver(Alloc);
+
   std::vector<StringRef> V;
   for (const lto::InputFile::Symbol &Sym : Obj->symbols())
     if (!Sym.isUndefined())
       V.push_back(Saver.save(Sym.getName()));
   return V;
 }
 
 // Returns a vector of globally-visible defined symbol names.