Subzero: Initial implementation of multithreaded translation.

src/llvm2ice.cpp

 //===- subzero/src/llvm2ice.cpp - Driver for testing ----------------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines a driver that uses LLVM capabilities to parse a
@@ skipping 185 matching lines @@
 static cl::opt<bool> AlwaysExitSuccess(
     "exit-success", cl::desc("Exit with success status, even if errors found"),
     cl::init(false));
 
 static cl::opt<bool>
 GenerateBuildAtts("build-atts",
                   cl::desc("Generate list of build attributes associated with "
                            "this executable."),
                   cl::init(false));
 
+// Number of translation threads (in addition to the parser thread and
+// the emitter thread).  The special case of 0 means purely
+// sequential, i.e. parser, translator, and emitter all within the
+// same single thread.  (This may need a slight rework if we expand to
+// multiple parser or emitter threads.)
+static cl::opt<uint32_t>
+NumThreads("threads",
+           cl::desc("Number of translation threads (0 for purely sequential)"),
+           // TODO(stichnot): Settle on a good default.  Consider
+           // something related to std::thread::hardware_concurrency().
+           cl::init(0));
+
 static int GetReturnValue(int Val) {
   if (AlwaysExitSuccess)
     return 0;
   return Val;
 }
 
 static struct {
   const char *FlagName;
   int FlagValue;
 } ConditionalBuildAttributes[] = {{"dump", ALLOW_DUMP},
@@ skipping 51 matching lines @@
   if (LogFilename != "-") {
     Lfs.open(LogFilename.c_str(), std::ofstream::out);
     Ls.reset(new raw_os_ostream(Lfs));
   } else {
     Ls.reset(new raw_os_ostream(std::cout));
   }
   Ls->SetUnbuffered();
 
   ValidateAndGenerateBuildAttributes(GenerateBuildAtts ? Ls.get() : nullptr);
   if (GenerateBuildAtts)
-    return GetReturnValue(0);
+    return GetReturnValue(Ice::EC_None);
 
   if (!ALLOW_DISABLE_IR_GEN && DisableIRGeneration) {
     *Ls << "Error: Build doesn't allow --no-ir-gen when not "
         << "ALLOW_DISABLE_IR_GEN!\n";
-    return GetReturnValue(1);
+    return GetReturnValue(Ice::EC_Args);
   }
 
   Ice::ClFlags Flags;
   Flags.DisableInternal = DisableInternal;
   Flags.SubzeroTimingEnabled = SubzeroTimingEnabled;
   Flags.DisableTranslation = DisableTranslation;
   Flags.FunctionSections = FunctionSections;
   Flags.DataSections = DataSections;
+  Flags.UseELFWriter = UseELFWriter;
   Flags.UseIntegratedAssembler = UseIntegratedAssembler;
-  Flags.UseELFWriter = UseELFWriter;
   Flags.UseSandboxing = UseSandboxing;
   Flags.PhiEdgeSplit = EnablePhiEdgeSplit;
   Flags.DecorateAsm = DecorateAsm;
   Flags.DumpStats = DumpStats;
   Flags.AllowUninitializedGlobals = AllowUninitializedGlobals;
   Flags.TimeEachFunction = TimeEachFunction;
+  Flags.NumTranslationThreads = NumThreads;
   Flags.DefaultGlobalPrefix = DefaultGlobalPrefix;
   Flags.DefaultFunctionPrefix = DefaultFunctionPrefix;
   Flags.TimingFocusOn = TimingFocusOn;
   Flags.VerboseFocusOn = VerboseFocusOn;
   Flags.TranslateOnly = TranslateOnly;
   Flags.DisableIRGeneration = DisableIRGeneration;
   Flags.AllowErrorRecovery = AllowErrorRecovery;
 
   // Force -build-on-read=0 for .ll files.
   const std::string LLSuffix = ".ll";
   if (IRFilename.length() >= LLSuffix.length() &&
       IRFilename.compare(IRFilename.length() - LLSuffix.length(),
                          LLSuffix.length(), LLSuffix) == 0)
     BuildOnRead = false;
 
   // With the ELF writer, use a raw_fd_ostream to allow seeking.
   // Also don't buffer, otherwise it gets pretty slow.
   std::unique_ptr<Ice::Ostream> Os;
   std::unique_ptr<Ice::ELFStreamer> ELFStr;
   std::ofstream Ofs;
   if (UseELFWriter) {
     if (OutputFilename == "-") {
       *Ls << "Error: writing binary ELF to stdout is unsupported\n";
-      return GetReturnValue(1);
+      return GetReturnValue(Ice::EC_Args);
     }
     std::string ErrorInfo;
     raw_fd_ostream *FdOs =
         new raw_fd_ostream(OutputFilename.c_str(), ErrorInfo, sys::fs::F_None);
     Os.reset(FdOs);
     if (!ErrorInfo.empty()) {
       *Ls << "Failed to open output file: " << OutputFilename << ":\n"
           << ErrorInfo << "\n";
-      return GetReturnValue(1);
+      return GetReturnValue(Ice::EC_Args);
     }
     ELFStr.reset(new Ice::ELFStreamer(*FdOs));
   } else {
     if (OutputFilename != "-") {
       Ofs.open(OutputFilename.c_str(), std::ofstream::out);
       Os.reset(new raw_os_ostream(Ofs));
     } else {
       Os.reset(new raw_os_ostream(std::cout));
     }
     Os->SetUnbuffered();
   }
 
   Ice::GlobalContext Ctx(Ls.get(), Os.get(), ELFStr.get(), VMask, TargetArch,
                          OptLevel, TestPrefix, Flags);
 
   Ice::TimerMarker T(Ice::TimerStack::TT_szmain, &Ctx);
 
   if (UseELFWriter) {
     Ice::TimerMarker T1(Ice::TimerStack::TT_emit, &Ctx);
     Ctx.getObjectWriter()->writeInitialELFHeader();
   }
 
-  int ErrorStatus = 0;
+  Ctx.startWorkerThreads();
+
+  std::unique_ptr<Ice::Translator> Translator;
   if (BuildOnRead) {
-    Ice::PNaClTranslator Translator(&Ctx, Flags);
-    Translator.translate(IRFilename);
-    ErrorStatus = Translator.getErrorStatus();
+    std::unique_ptr<Ice::PNaClTranslator> PTranslator(
+        new Ice::PNaClTranslator(&Ctx, Flags));
+    PTranslator->translate(IRFilename);
+    Translator.reset(PTranslator.release());
   } else if (ALLOW_LLVM_IR) {
     // Parse the input LLVM IR file into a module.
     SMDiagnostic Err;
     Ice::TimerMarker T1(Ice::TimerStack::TT_parse, &Ctx);
     raw_ostream *Verbose = LLVMVerboseErrors ? &errs() : nullptr;
     Module *Mod =
         NaClParseIRFile(IRFilename, InputFileFormat, Err, Verbose,
                         getGlobalContext());
 
     if (!Mod) {
       Err.print(argv[0], errs());
-      return GetReturnValue(1);
+      return GetReturnValue(Ice::EC_Bitcode);
     }
 
-    Ice::Converter Converter(Mod, &Ctx, Flags);
-    Converter.convertToIce();
-    ErrorStatus = Converter.getErrorStatus();
+    std::unique_ptr<Ice::Converter> Converter(
+        new Ice::Converter(Mod, &Ctx, Flags));
+    Converter->convertToIce();
+    Translator.reset(Converter.release());
   } else {
     *Ls << "Error: Build doesn't allow LLVM IR, "
         << "--build-on-read=0 not allowed\n";
-    return GetReturnValue(1);
+    return GetReturnValue(Ice::EC_Args);
   }
+
+  Ctx.waitForWorkerThreads();
+  Translator->transferErrorCode();
+  Translator->emitConstants();
+
   if (UseELFWriter) {
     Ice::TimerMarker T1(Ice::TimerStack::TT_emit, &Ctx);
     Ctx.getObjectWriter()->writeNonUserSections();
   }
   if (SubzeroTimingEnabled)
     Ctx.dumpTimers();
   if (TimeEachFunction) {
     const bool DumpCumulative = false;
     Ctx.dumpTimers(Ice::GlobalContext::TSK_Funcs, DumpCumulative);
   }
   const bool FinalStats = true;
   Ctx.dumpStats("_FINAL_", FinalStats);
-  return GetReturnValue(ErrorStatus);
+  return GetReturnValue(Ctx.getErrorStatus()->value());
 }