Exit early

[• rafael]

Summary

When linking our job is done as soon as the file is written, and the liker can just exit.

The situation is a bit more complicated with the current library arrangements since we unfortunately support running in the same process.

This is in the noise when linking clang, but with scyla it goes from 3.894365061 seconds to 3.879345710 seconds (1.0038 times faster). It would be interesting to see numbers on windows too, but I only have a windows VM.

[ruiu]

1.0038x is not a large difference. We may be OK with this patch, but can you find a stronger evidence that exiting like this is more effective than that?

[• rafael]

I wrote it mostly for sanity when benchmarking other ideas of how to
write the data out. For example, I want to properly benchmark using
anonymous memory + write and play with async write, but want to make
sure to not include extra shutdown costs.

I will benchmark it on OS X (laptop) and windows (VM).

On OS X there is no perf, so I had to write a small python script to
time it (attached).

clang: 1.016X faster.

scylla: 1.004X faster.

Cheers,
Rafael

• time-it.py13 KBDownload

[• rafael]

On windows calling _exit actually seems a bit slower (but measuring on the VM is really noisy).

I will keep this as a local branch for now to use when testing other changes and bring it up again if it is particularly beneficial at some point.

ELF/Config.h

struct Configuration {
   bool StripAll;
   bool SysvHash = true;
   bool Verbose;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  bool ExitEarly;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t EntryAddr = -1;
   unsigned Optimize = 0;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/Driver.h

 #include "llvm/Support/raw_ostream.h"
 
 namespace lld {
 namespace elf2 {
 
 extern class LinkerDriver *Driver;
 
 // Entry point of the ELF linker. Returns true on success.
-bool link(ArrayRef<const char *> Args, llvm::raw_ostream &Error = llvm::errs());
+bool link(ArrayRef<const char *> Args, bool CanExitEarly = false,
+          llvm::raw_ostream &Error = llvm::errs());
 
 class LinkerDriver {
 public:
-  void main(ArrayRef<const char *> Args);
+  void main(ArrayRef<const char *> Args, bool CanExitEarly);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
 
 private:
-  void readConfigs(llvm::opt::InputArgList &Args);
+  void readConfigs(llvm::opt::InputArgList &Args, bool CanExitEarly);
   void createFiles(llvm::opt::InputArgList &Args);
   template <class ELFT> void link(llvm::opt::InputArgList &Args);
 
   llvm::BumpPtrAllocator Alloc;
   bool WholeArchive = false;
   std::vector<std::unique_ptr<InputFile>> Files;
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };

ELF/Driver.cpp

 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 Configuration *elf2::Config;
 LinkerDriver *elf2::Driver;
 
-bool elf2::link(ArrayRef<const char *> Args, raw_ostream &Error) {
+bool elf2::link(ArrayRef<const char *> Args, bool CanExitEarly,
+                raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
   Configuration C;
   LinkerDriver D;
   LinkerScript LS;
   Config = &C;
   Driver = &D;
   Script = &LS;
-  Driver->main(Args.slice(1));
+  Driver->main(Args.slice(1), CanExitEarly);
   return !HasError;
 }
 
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef S) {
   if (S == "elf32btsmip")
     return {ELF32BEKind, EM_MIPS};
   if (S == "elf32ltsmip")
     return {ELF32LEKind, EM_MIPS};

 
 static bool hasZOption(opt::InputArgList &Args, StringRef Key) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (Key == Arg->getValue())
       return true;
   return false;
 }
 
-void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
+void LinkerDriver::main(ArrayRef<const char *> ArgsArr, bool CanExitEarly) {
   initSymbols();
 
   opt::InputArgList Args = parseArgs(&Alloc, ArgsArr);
-  readConfigs(Args);
+  readConfigs(Args, CanExitEarly);
   createFiles(Args);
   checkOptions(Args);
   if (HasError)
     return;
 
   switch (Config->EKind) {
   case ELF32LEKind:
     link<ELF32LE>(Args);
     return;
   case ELF32BEKind:
     link<ELF32BE>(Args);
     return;
   case ELF64LEKind:
     link<ELF64LE>(Args);
     return;
   case ELF64BEKind:
     link<ELF64BE>(Args);
     return;
   default:
     error("-m or at least a .o file required");
   }
 }
 
 // Initializes Config members by the command line options.
-void LinkerDriver::readConfigs(opt::InputArgList &Args) {
+void LinkerDriver::readConfigs(opt::InputArgList &Args, bool CanExitEarly) {
   for (auto *Arg : Args.filtered(OPT_L))
     Config->SearchPaths.push_back(Arg->getValue());
 
   std::vector<StringRef> RPaths;
   for (auto *Arg : Args.filtered(OPT_rpath))
     RPaths.push_back(Arg->getValue());
   if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
void LinkerDriver::readConfigs(opt::InputArgList &Args, bool CanExitEarly) {
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->GcSections = Args.hasArg(OPT_gc_sections);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
   Config->PrintGcSections = Args.hasArg(OPT_print_gc_sections);
   Config->Shared = Args.hasArg(OPT_shared);
   Config->StripAll = Args.hasArg(OPT_strip_all);
   Config->Verbose = Args.hasArg(OPT_verbose);
+  Config->ExitEarly = CanExitEarly && !Args.hasArg(OPT_full_shutdown);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);

ELF/Options.td

def entry : Separate<["--", "-"], "entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def export_dynamic : Flag<["--", "-"], "export-dynamic">,
   HelpText<"Put symbols in the dynamic symbol table">;
 
 def fini : Separate<["-"], "fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
+def full_shutdown : Flag<["--"], "full-shutdown">,  HelpText<"foobar">;
+
 def hash_style : Separate<["--", "-"], "hash-style">,
   HelpText<"Specify hash style (sysv, gnu or both)">;
 
 def gc_sections : Flag<["--"], "gc-sections">,
   HelpText<"Enable garbage collection of unused sections">;
 
 def init : Separate<["-"], "init">, MetaVarName<"<symbol>">,
   HelpText<"Specify an initializer function">;

ELF/Writer.cpp

 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/StringSaver.h"
 #include "llvm/Support/raw_ostream.h"
 
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 namespace {
template <class ELFT> void Writer<ELFT>::run() {
   fixAbsoluteSymbols();
   if (!openFile())
     return;
   writeHeader();
   writeSections();
   if (HasError)
     return;
   fatal(Buffer->commit());
+  if (Config->ExitEarly)
+    _exit(0);
 }
 
 namespace {
 template <bool Is64Bits> struct SectionKey {
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
   StringRef Name;
   uint32_t Type;
   uintX_t Flags;

include/lld/Driver/Driver.h

 };
 
 /// Driver for Windows 'link.exe' command line options
 namespace coff {
 void link(llvm::ArrayRef<const char *> args);
 }
 
 namespace elf2 {
-bool link(llvm::ArrayRef<const char *> args, raw_ostream &diag = llvm::errs());
+bool link(llvm::ArrayRef<const char *> args, bool CanExitEarly = false,
+          raw_ostream &diag = llvm::errs());
 }
 
 /// Driver for lld unit tests
 class CoreDriver : public Driver {
 public:
   /// Parses command line arguments same as lld-core and performs link.
   /// Returns true iff there was an error.
   static bool link(llvm::ArrayRef<const char *> args,

lib/Driver/UniversalDriver.cpp

bool UniversalDriver::link(llvm::MutableArrayRef<const char *> args,
 
   Flavor flavor = getFlavor(args, parsedArgs);
 
   // Switch to appropriate driver.
   switch (flavor) {
   case Flavor::old_gnu_ld:
     return GnuLdDriver::linkELF(args, diagnostics);
   case Flavor::gnu_ld:
-    return elf2::link(args, diagnostics);
+    return elf2::link(args, true, diagnostics);
   case Flavor::darwin_ld:
     return DarwinLdDriver::linkMachO(args, diagnostics);
   case Flavor::win_link:
     coff::link(args);
     return true;
   case Flavor::core:
     return CoreDriver::link(args, diagnostics);
   case Flavor::invalid:
     diagnostics << "Select the appropriate flavor\n";
     table.PrintHelp(llvm::outs(), programName.data(), "LLVM Linker", false);
     return false;
   }
   llvm_unreachable("Unrecognised flavor");
 }
 
 } // end namespace lld