Allow Subzero to parse function blocks in parallel.

src/IceCompiler.cpp

 //===- subzero/src/IceCompiler.cpp - Driver for bitcode translation -------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 96 matching lines @@
                         llvm::getGlobalContext(), DiagnosticHandler);
     if (!Mod) {
       Err.print(Flags.getAppName().c_str(), llvm::errs());
       Ctx.getErrorStatus()->assign(EC_Bitcode);
       return;
     }
 
     std::unique_ptr<Converter> Converter(new class Converter(Mod.get(), &Ctx));
     Converter->convertToIce();
     Translator.reset(Converter.release());
+    Ctx.waitForWorkerThreads();

[John, 2016/03/24 17:32:34]

I don't understand this change.

[Karl, 2016/03/24 17:37:49]

For the bitcode reader, we must move this call inside the bitcode parser, so
that the module block doesn't disappear until all function blocks are parsed
(this is needed because the parse state is held in the module block parser).
Hence, we can't apply in this method for all cases.

Therefore, for the bitcode parser (lines 83-87), we don't call it. Only if the
IceConverter is called, do we call it in this method.

[John, 2016/03/24 17:44:00]

ok, maybe add a comment here? I get nervous when I look at code that does:

startThreads()

if (Cond) {
  joinThreads();
}

terminateProcessing();

[Karl, 2016/03/24 22:35:25]

I looked at the code more carefully, and (due to possible errors) the bitcode
parser can terminate in several places. To make it easier to deal with this, I
made WaitForWorkerThreads() only apply once, no matter how many times it is
called.

This also allows me to keep you general pattern here.

   } else {
     Ctx.getStrError() << "Error: Build doesn't allow LLVM IR, "
                       << "--build-on-read=0 not allowed\n";
     Ctx.getErrorStatus()->assign(EC_Args);
     return;
   }
 
-  Ctx.waitForWorkerThreads();
   if (Translator->getErrorStatus()) {
     Ctx.getErrorStatus()->assign(Translator->getErrorStatus().value());
   } else {
     Ctx.lowerGlobals("last");
     Ctx.lowerProfileData();
     Ctx.lowerConstants();
     Ctx.lowerJumpTables();
 
     if (Ctx.getFlags().getOutFileType() == FT_Elf) {
       TimerMarker T1(Ice::TimerStack::TT_emitAsm, &Ctx);
       Ctx.getObjectWriter()->setUndefinedSyms(Ctx.getConstantExternSyms());
       Ctx.getObjectWriter()->writeNonUserSections();
     }
   }
 
   if (Ctx.getFlags().getSubzeroTimingEnabled())
     Ctx.dumpTimers();
 
   if (Ctx.getFlags().getTimeEachFunction()) {
     constexpr bool NoDumpCumulative = false;
     Ctx.dumpTimers(GlobalContext::TSK_Funcs, NoDumpCumulative);
   }
   constexpr bool FinalStats = true;
   Ctx.dumpStats("_FINAL_", FinalStats);
 }
 
 } // end of namespace Ice