Subzero: Initial implementation of multithreaded translation.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 113 matching lines @@
     Str << "(requires '-track-memory')";
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit,
                              ELFStreamer *ELFStr, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
-      TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter() {
+      TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter(),
+      CfgQ(Flags.NumTranslationThreads), ErrorStatus(false) {
   // Create a new ThreadContext for the current thread.  No need to
   // lock AllThreadContexts at this point since no other threads have
   // access yet to this GlobalContext object.
   AllThreadContexts.push_back(new ThreadContext());
   TLS = AllThreadContexts.back();
   // Pre-register built-in stack names.
   if (ALLOW_DUMP) {
     // TODO(stichnot): There needs to be a strong relationship between
     // the newTimerStackID() return values and TSK_Default/TSK_Funcs.
     newTimerStackID("Total across all functions");
     newTimerStackID("Per-function summary");
   }
   if (Flags.UseELFWriter) {
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
   }
 }
 
+void GlobalContext::translateFunctions() {
+  while (Cfg *Func = cfgQueueGet()) {
+    resetStats();

[Jim Stichnoth, 2015/01/22 19:10:29]

Most of this function was moved from Translator::translateFcn() in
IceTranslator.cpp.

+    Func->updateTLS();
+    if (!matchSymbolName(Func->getFunctionName(), getFlags().VerboseFocusOn))
+      Func->setVerbose(IceV_None);
+    if (getFlags().DisableTranslation ||
+        !matchSymbolName(Func->getFunctionName(), getFlags().TranslateOnly)) {
+      Func->dump();

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

What are the above two for?

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

Documented.

+    } else {
+      Func->translate();
+      if (Func->hasError()) {
+        OstreamLocker L(this);
+        getStrDump() << "ICE translation error: " << Func->getError() << "\n";
+        ErrorStatus = true;

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

Should the thread continue when it has errors? Shouldn't the errors be in a
container otherwise (so you know how many you received, and what they were)?

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

I do want to continue on an error, to give the user more information.  But I
don't know what to do beyond printing them and tracking whether the number of
errors is zero or nonzero (which is what's being done now).

+      } else {
+        if (getFlags().UseIntegratedAssembler)
+          Func->emitIAS();
+        else
+          Func->emit();
+        // TODO(stichnot): actually add to emit queue
+      }
+      dumpStats(Func->getFunctionName());

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

I think the stats should be joined at the end of the translation thread, and
kept in TLS during translation.

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

Per-function stats should be dumped at this point, but you're right that
cumulative stats should be stored in TLS and joined at the end.  Added a TODO.

+    }
+    delete Func;

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

Could you use unique_ptr so that you don't need to delete manually?

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

There's already a TODO in IceCfg.h:33 about this.

+  }
+}
+
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
 // following substitution string like "S1_" or "PS1_" may be combined
 // with the previous type.
@@ skipping 295 matching lines @@
 }
 
 TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
                                    const IceString &Name) {
   auto Timers = getTimers();
   assert(StackID < Timers->size());
   return Timers->at(StackID).getTimerID(Name);
 }
 
 void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
+  // TODO(stichnot): Timers are completely broken for multithreading; fix.
+  if (getFlags().NumTranslationThreads)
+    return;

[jvoung (off chromium), 2015/01/22 23:06:06]

Could report_fatal_error for now?

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

Done.

   auto Timers = getTimers();
   assert(StackID < Timers->size());
   Timers->at(StackID).push(ID);
 }
 
 void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
+  // TODO(stichnot): Timers are completely broken for multithreading; fix.
+  if (getFlags().NumTranslationThreads)
+    return;
   auto Timers = getTimers();
   assert(StackID < Timers->size());
   Timers->at(StackID).pop(ID);
 }
 
 void GlobalContext::resetTimer(TimerStackIdT StackID) {
   auto Timers = getTimers();
   assert(StackID < Timers->size());
   Timers->at(StackID).reset();
 }
@@ skipping 31 matching lines @@
   if (ALLOW_DUMP) {
     Active = Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled;
     if (Active)
       Ctx->pushTimer(ID);
   }
 }
 
 thread_local GlobalContext::ThreadContext *GlobalContext::TLS;
 
 } // end of namespace Ice