Subzero: Emit functions and global initializers in a separate thread.

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 116 matching lines @@
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit,
                              ELFStreamer *ELFStr, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
       StrEmit(OsEmit), VMask(Mask), Arch(Arch), Opt(Opt),
       TestPrefix(TestPrefix), Flags(Flags), RNG(""), ObjectWriter(),
-      CfgQ(/*MaxSize=*/Flags.getNumTranslationThreads(),
-           /*Sequential=*/(Flags.getNumTranslationThreads() == 0)) {
+      OptQ(/*Sequential=*/Flags.isSequential(),
+           /*MaxSize=*/Flags.getNumTranslationThreads()),
+      // EmitQ is allowed unlimited size.
+      EmitQ(/*Sequential=*/Flags.isSequential()) {
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
   // main() so that all clients (e.g. unit tests) can benefit for
   // free.
   GlobalContext::TlsInit();
   Cfg::TlsInit();
   // 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.
   ThreadContext *MyTLS = new ThreadContext();
   AllThreadContexts.push_back(MyTLS);
   ICE_TLS_SET_FIELD(TLS, MyTLS);
   // 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");
   }
   Timers.initInto(MyTLS->Timers);
   if (Flags.getUseELFWriter()) {
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
   }
 }
 
 void GlobalContext::translateFunctions() {
-  while (std::unique_ptr<Cfg> Func = cfgQueueBlockingPop()) {
+  while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     Cfg::setCurrentCfg(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
     if (!matchSymbolName(Func->getFunctionName(),
                          getFlags().getVerboseFocusOn()))
       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().getDisableTranslation() ||
         !matchSymbolName(Func->getFunctionName(),
                          getFlags().getTranslateOnly())) {
       Func->dump();
+      Cfg::setCurrentCfg(nullptr);
+      continue; // Func goes out of scope and gets deleted
+    }
+    Func->translate();
+    EmitterWorkItem *Item = nullptr;
+    if (Func->hasError()) {
+      getErrorStatus()->assign(EC_Translation);
+      OstreamLocker L(this);
+      getStrDump() << "ICE translation error: " << Func->getError() << "\n";
+      Item = new EmitterWorkItem(Func->getSequenceNumber());
     } else {
-      Func->translate();
-      if (Func->hasError()) {
-        getErrorStatus()->assign(EC_Translation);
-        OstreamLocker L(this);
-        getStrDump() << "ICE translation error: " << Func->getError() << "\n";
+      if (getFlags().getUseIntegratedAssembler()) {
+        Func->emitIAS();
+        // The Cfg has already emitted into the assembly buffer, so
+        // stats have been fully collected into this thread's TLS.
+        // Dump them before TLS is reset for the next Cfg.
+        dumpStats(Func->getFunctionName());
+        Assembler *Asm = Func->releaseAssembler();
+        // Copy relevant fields into Asm before Func is deleted.
+        Asm->setFunctionName(Func->getFunctionName());
+        Asm->setInternal(Func->getInternal());
+        Item = new EmitterWorkItem(Func->getSequenceNumber(), Asm);
       } else {
-        if (getFlags().getUseIntegratedAssembler())
-          Func->emitIAS();
-        else
-          Func->emit();
-        // TODO(stichnot): actually add to emit queue
+        // The Cfg has not been emitted yet, so stats are not ready
+        // to be dumped.
+        Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
       }
-      dumpStats(Func->getFunctionName());
     }
     Cfg::setCurrentCfg(nullptr);
+    assert(Item);
+    emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
+namespace {
+
+void lowerGlobals(GlobalContext *Ctx,
+                  std::unique_ptr<VariableDeclarationList> VariableDeclarations,
+                  TargetDataLowering *DataLowering) {
+  TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
+  const bool DumpGlobalVariables = ALLOW_DUMP && Ctx->getVerbose() &&
+                                   Ctx->getFlags().getVerboseFocusOn().empty();
+  if (DumpGlobalVariables) {
+    OstreamLocker L(Ctx);
+    Ostream &Stream = Ctx->getStrDump();
+    for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
+      Global->dump(Ctx, Stream);
+    }
+  }
+  if (Ctx->getFlags().getDisableTranslation())
+    return;
+  DataLowering->lowerGlobals(std::move(VariableDeclarations));
+}
+
+// Ensure Pending is large enough that Pending[Index] is valid.
+void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
+  if (Index >= Pending.size())
+    Pending.resize(Index + 1);
+}
+
+} // end of anonymous namespace
+
+void GlobalContext::emitItems() {
+  const bool Threaded = !getFlags().isSequential();
+  // Pending is a vector containing the reassembled, ordered list of
+  // work items.  When we're ready for the next item, we first check
+  // whether it's in the Pending list.  If not, we take an item from
+  // the work queue, and if it's not the item we're waiting for, we
+  // insert it into Pending and repeat.  The work item is deleted
+  // after it is processed.
+  std::vector<EmitterWorkItem *> Pending;
+  uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
+  while (true) {
+    resizePending(Pending, DesiredSequenceNumber);
+    // See if Pending contains DesiredSequenceNumber.
+    EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
+    if (RawItem == nullptr)
+      RawItem = emitQueueBlockingPop();
+    if (RawItem == nullptr)
+      return;
+    uint32_t ItemSeq = RawItem->getSequenceNumber();
+    if (Threaded && ItemSeq != DesiredSequenceNumber) {
+      resizePending(Pending, ItemSeq);
+      Pending[ItemSeq] = RawItem;
+      continue;
+    }
+
+    std::unique_ptr<EmitterWorkItem> Item(RawItem);
+    ++DesiredSequenceNumber;
+    switch (Item->getKind()) {
+    case EmitterWorkItem::WI_Nop:
+      break;
+    case EmitterWorkItem::WI_GlobalInits: {
+      lowerGlobals(this, Item->getGlobalInits(),
+                   TargetDataLowering::createLowering(this).get());
+    } break;
+    case EmitterWorkItem::WI_Asm: {
+      std::unique_ptr<Assembler> Asm = Item->getAsm();
+      Asm->alignFunction();
+      IceString MangledName = mangleName(Asm->getFunctionName());
+      if (getFlags().getUseELFWriter()) {
+        getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
+                                             Asm.get());
+      } else {
+        OstreamLocker L(this);
+        Cfg::emitTextHeader(MangledName, this, Asm.get());
+        Asm->emitIASBytes(this);
+      }
+    } break;
+    case EmitterWorkItem::WI_Cfg: {
+      if (!ALLOW_DUMP)
+        llvm::report_fatal_error("WI_Cfg work item created inappropriately");
+      assert(!getFlags().getUseIntegratedAssembler());
+      std::unique_ptr<Cfg> Func = Item->getCfg();
+      // Unfortunately, we have to temporarily install the Cfg in TLS
+      // because Variable::asType() uses the allocator to create the
+      // differently-typed copy.
+      Cfg::setCurrentCfg(Func.get());
+      Func->emit();
+      Cfg::setCurrentCfg(nullptr);
+      dumpStats(Func->getFunctionName());
+    } break;
+    }
+  }
+}
+
 // 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 330 matching lines @@
   Timers->at(StackID).reset();
 }
 
 void GlobalContext::setTimerName(TimerStackIdT StackID,
                                  const IceString &NewName) {
   auto Timers = &ICE_TLS_GET_FIELD(TLS)->Timers;
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
-// Note: cfgQueueBlockingPush and cfgQueueBlockingPop use unique_ptr
+// Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr
 // at the interface to take and transfer ownership, but they
 // internally store the raw Cfg pointer in the work queue.  This
 // allows e.g. future queue optimizations such as the use of atomics
 // to modify queue elements.
-void GlobalContext::cfgQueueBlockingPush(std::unique_ptr<Cfg> Func) {
-  CfgQ.blockingPush(Func.release());
+void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
+  assert(Func);
+  OptQ.blockingPush(Func.release());
+  if (getFlags().isSequential())
+    translateFunctions();
 }
 
-std::unique_ptr<Cfg> GlobalContext::cfgQueueBlockingPop() {
-  return std::unique_ptr<Cfg>(CfgQ.blockingPop());
+std::unique_ptr<Cfg> GlobalContext::optQueueBlockingPop() {
+  return std::unique_ptr<Cfg>(OptQ.blockingPop());
+}
+
+void GlobalContext::emitQueueBlockingPush(EmitterWorkItem *Item) {
+  assert(Item);
+  EmitQ.blockingPush(Item);
+  if (getFlags().isSequential())
+    emitItems();
+}
+
+EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
+  return EmitQ.blockingPop();
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!getFlags().getDumpStats())
     return;
   OstreamLocker OL(this);
   if (Final) {
     getStatsCumulative()->dump(Name, getStrDump());
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
@@ skipping 28 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice