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));
 
+static cl::opt<uint32_t>
+NumThreads("threads",
+           cl::desc("Number of translation threads (0 for purely sequential)"),
+           cl::init(0));

[JF, 2015/01/22 20:50:56]

This should default to std::thread::hardware_concurrency.

It's a bit confusing to have 0 and 1 be sequential, though 1 does generate a
thread whereas 0 doesn't.

[Jim Stichnoth, 2015/01/23 07:55:55]

Well, 1 isn't exactly sequential, as there would be one translation thread in
addition to the parser thread and (eventually) the emitter thread.  0 means
everything is purely sequential with a single thread for everything, just as it
is pre-CL.

I added a comment to the code, but there's not much more space available in the
description string.

As for a std::thread::hardware_concurrency() default: maybe, or maybe that minus
2 to accommodate parser and emitter threads, or some browser max, or some
browser max minus 2, or some other resource balancing logic?  Added a TODO. :) 
For now, I'd keep it 0 to be minimally invasive while the dust settles (and
until I get tsan builds).  Later, at least 2 for recombobulation testing.

+static cl::alias SplitModule("split-module", cl::desc("Alias for -threads"),

[Karl, 2015/01/22 20:41:13]

Not sure this can be an alias. Single threaded for pnacl-llc assume
split-module=1?

[JF, 2015/01/22 20:50:56]

Why add the alias at all?

[Jim Stichnoth, 2015/01/23 07:55:55]

The idea was to make it easier to plumb llvm2ice alongside pnacl-llc in the
pnacl-translate script.  (Despite its misleading name.)

But OK OK I dropped it.

+                             cl::NotHidden, cl::aliasopt(NumThreads));
+
 static int GetReturnValue(int Val) {
   if (AlwaysExitSuccess)
     return 0;
   return Val;
 }
 
 static struct {
   const char *FlagName;
   int FlagValue;
 } ConditionalBuildAttributes[] = {{"dump", ALLOW_DUMP},
@@ skipping 65 matching lines @@
         << "ALLOW_DISABLE_IR_GEN!\n";
     return GetReturnValue(1);
   }
 
   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";
@@ skipping 35 matching lines @@
   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();
   }
 
+  Ctx.startWorkerThreads();
+
   int ErrorStatus = 0;

[JF, 2015/01/22 20:50:56]

This should also be an std::vector<std::error_code>.

[Jim Stichnoth, 2015/01/23 07:55:55]

Changed to std::error_code.

   if (BuildOnRead) {
     Ice::PNaClTranslator Translator(&Ctx, Flags);
     Translator.translate(IRFilename);
     ErrorStatus = Translator.getErrorStatus();
   } 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);
     }
 
     Ice::Converter Converter(Mod, &Ctx, Flags);
     Converter.convertToIce();
     ErrorStatus = Converter.getErrorStatus();
   } else {
     *Ls << "Error: Build doesn't allow LLVM IR, "
         << "--build-on-read=0 not allowed\n";
     return GetReturnValue(1);
   }
+  // Error status is the combination of the bitcode parser's error
+  // status and the translation error status.
+  ErrorStatus |= Ctx.getErrorStatus();
+
   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);
 }