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 117 matching lines @@
 }
 
 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)) {
+           /*Sequential=*/(Flags.NumTranslationThreads == 0)),
+      EmitQ(/*MaxSize=*/Flags.NumTranslationThreads,

[JF, 2015/02/08 00:29:47]

Translation an emit thread numbers should be independent.

[Jim Stichnoth, 2015/02/08 17:11:23]

Oops, cargo-cult error.

The Sequential logic is the same for both queues.  I'll change it to
Flags.isSequential() after Karl's Flags refactoring lands.

Changed the emit queue to allow unlimited size, up to the hard limit on the
underlying array size.

+            /*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();
@@ skipping 22 matching lines @@
     // 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,

[Jim Stichnoth, 2015/02/07 14:53:07]

This is moved largely unchanged from Translator::lowerGlobals() in
IceTranslator.cpp.

+                  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: {
+      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 339 matching lines @@
   assert(StackID < Timers->size());
   Timers->at(StackID).setName(NewName);
 }
 
 // Note: cfgQueueBlockingPush and cfgQueueBlockingPop 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) {
+  assert(Func);
   CfgQ.blockingPush(Func.release());
+  if (getFlags().NumTranslationThreads == 0)
+    translateFunctions();
 }
 
 std::unique_ptr<Cfg> GlobalContext::cfgQueueBlockingPop() {
   return std::unique_ptr<Cfg>(CfgQ.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 22 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