Allow Subzero to parse function blocks in parallel.

src/IceCompiler.cpp

Index: src/IceCompiler.cpp
diff --git a/src/IceCompiler.cpp b/src/IceCompiler.cpp
index bd5e8343a554bf1ada85fd1da831f64ce6007770..5d635c5f5cd2c58b7d684fe041486dc434a4cd90 100644
--- a/src/IceCompiler.cpp
+++ b/src/IceCompiler.cpp
@@ -114,6 +114,7 @@ void Compiler::run(const Ice::ClFlags &Flags, GlobalContext &Ctx,
     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";
@@ -121,7 +122,6 @@ void Compiler::run(const Ice::ClFlags &Flags, GlobalContext &Ctx,
     return;
   }
 
-  Ctx.waitForWorkerThreads();
   if (Translator->getErrorStatus()) {
     Ctx.getErrorStatus()->assign(Translator->getErrorStatus().value());
   } else {