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, (Flags.NumTranslationThreads == 0)),

[JF, 2015/01/23 17:22:43]

Add /*MaxSize=*/ and /*Sequential=*/ here.

[Jim Stichnoth, 2015/01/23 21:54:02]

Nice, done.

+      ErrorStatus() {
   // 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()) {
+    // Reset per-function stats being accumulated in TLS.
+    resetStats();
+    // Install Func in TLS for Cfg-specific container allocators.
+    Func->updateTLS();
+    // Set verbose level to none if the current function does NOT
+    // match the -verbose-focus command-line option.
+    if (!matchSymbolName(Func->getFunctionName(), getFlags().VerboseFocusOn))
+      Func->setVerbose(IceV_None);
+    // Disable translation if -notranslate is specified, or if the
+    // current function matches the -translate-only option.  If
+    // translation is disabled, just dump the high-level IR and
+    // continue.
+    if (getFlags().DisableTranslation ||
+        !matchSymbolName(Func->getFunctionName(), getFlags().TranslateOnly)) {
+      Func->dump();
+    } else {
+      Func->translate();
+      if (Func->hasError()) {
+        OstreamLocker L(this);
+        getStrDump() << "ICE translation error: " << Func->getError() << "\n";
+        ErrorStatus.assign(1, std::generic_category());
+      } else {
+        if (getFlags().UseIntegratedAssembler)
+          Func->emitIAS();
+        else
+          Func->emit();
+        // TODO(stichnot): actually add to emit queue
+      }
+      // TODO(stichnot): fix multithreaded stats dumping.
+      dumpStats(Func->getFunctionName());
+    }
+    delete Func;
+  }
+}
+
 // 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)
+    llvm::report_fatal_error("Timers and multithreading are currently broken");
   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)
+    llvm::report_fatal_error("Timers and multithreading are currently broken");
   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