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.NumTranslationThreads,
-           /*Sequential=*/(Flags.NumTranslationThreads == 0)) {
+      OptQ(/*Sequential=*/(Flags.NumTranslationThreads == 0),
+           /*MaxSize=*/Flags.NumTranslationThreads),
+      // EmitQ is allowed unlimited size.
+      EmitQ(/*Sequential=*/(Flags.NumTranslationThreads == 0)) {
   // 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.UseELFWriter) {
     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().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();
+      Cfg::setCurrentCfg(nullptr);
     } else {
       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 {
-        if (getFlags().UseIntegratedAssembler)
+        if (getFlags().UseIntegratedAssembler) {
           Func->emitIAS();
-        else
-          Func->emit();
-        // TODO(stichnot): actually add to emit queue
+          // 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 {
+          // The Cfg has not been emitted yet, so stats are not ready
+          // to be dumped.
+          Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
+        }
       }
+      Cfg::setCurrentCfg(nullptr);
+      assert(Item);
+      emitQueueBlockingPush(Item);
+    }
+    // The Cfg now gets deleted as Func goes out of scope.
+  }
+}
+
+namespace {
+
+void lowerGlobals(GlobalContext *Ctx,
+                  VariableDeclarationList *VariableDeclarations,
+                  TargetDataLowering *DataLowering) {
+  TimerMarker T(TimerStack::TT_emitGlobalInitializers, Ctx);
+  bool DisableTranslation = Ctx->getFlags().DisableTranslation;
+  const bool DumpGlobalVariables =
+      ALLOW_DUMP && Ctx->getVerbose() && Ctx->getFlags().VerboseFocusOn.empty();
+  if (Ctx->getFlags().UseELFWriter) {
+    // Dump all globals if requested, but don't interleave w/ emission.
+    if (DumpGlobalVariables) {
+      OstreamLocker L(Ctx);
+      Ostream &Stream = Ctx->getStrDump();
+      for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
+        Global->dump(Ctx, Stream);
+      }
+    }
+    DataLowering->lowerGlobalsELF(*VariableDeclarations);
+  } else {
+    const IceString &TranslateOnly = Ctx->getFlags().TranslateOnly;
+    OstreamLocker L(Ctx);
+    Ostream &Stream = Ctx->getStrDump();
+    for (const Ice::VariableDeclaration *Global : *VariableDeclarations) {
+      // Interleave dump output w/ emit output.
+      if (DumpGlobalVariables)
+        Global->dump(Ctx, Stream);
+      if (!DisableTranslation &&
+          GlobalContext::matchSymbolName(Global->getName(), TranslateOnly))
+        DataLowering->lowerGlobal(*Global);
+    }
+  }
+}
+
+// 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().NumTranslationThreads;
+  // 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 *Item = Pending[DesiredSequenceNumber];
+    if (Item == nullptr)
+      Item = emitQueueBlockingPop();
+    if (Item == nullptr)
+      return;
+    uint32_t ItemSeq = Item->getSequenceNumber();
+    if (Threaded && ItemSeq != DesiredSequenceNumber) {
+      resizePending(Pending, ItemSeq);
+      Pending[ItemSeq] = Item;
+      continue;
+    }
+
+    ++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: {
+      Assembler *Asm = Item->getAsm();
+      Asm->alignFunction();
+      IceString MangledName = mangleName(Asm->getFunctionName());
+      if (getFlags().UseELFWriter) {
+        getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
+                                             Asm);
+      } else {
+        OstreamLocker L(this);
+        Cfg::emitTextHeader(MangledName, this, Asm);
+        Asm->emitIASBytes(this);
+      }
+    } break;
+    case EmitterWorkItem::WI_Cfg: {
+      if (!ALLOW_DUMP)
+        llvm::report_fatal_error("WI_Cfg work item created inappropriately");
+      assert(!getFlags().UseIntegratedAssembler);
+      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);
+      Func->emit();
+      Cfg::setCurrentCfg(nullptr);
       dumpStats(Func->getFunctionName());
+    } break;
     }
-    Cfg::setCurrentCfg(nullptr);
-    // The Cfg now gets deleted as Func goes out of scope.
+    delete Item;
   }
 }
 
 // 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
@@ skipping 333 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().NumTranslationThreads == 0)
+    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().NumTranslationThreads == 0)
+    emitItems();
+}
+
+EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
+  return EmitQ.blockingPop();
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!ALLOW_DUMP || !getFlags().DumpStats)
     return;
   OstreamLocker OL(this);
   if (Final) {
     getStatsCumulative()->dump(Name, getStrDump());
   } else {
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.dump(Name, getStrDump());
@@ skipping 24 matching lines @@
     Ctx->pushTimer(ID, StackID);
 }
 
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active = Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled;
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
+EmitterWorkItem::~EmitterWorkItem() {
+  // TODO(kschimpf,stichnot): Delete GlobalInits once it is managed in
+  // the parser as a unique_ptr.
+
+  // delete GlobalInits;
+  delete Function;
+  delete RawFunc;
+}
+
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice