Subzero: Initial implementation of multithreaded translation.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the skeleton of the TargetLowering class,
@@ skipping 83 matching lines @@
     return IceTargetX8664::create(Func);
   if (Target == Target_ARM32)
     return IceTargetARM32::create(Func);
   if (Target == Target_ARM64)
     return IceTargetARM64::create(Func);
 #endif
   Func->setError("Unsupported target");
   return nullptr;
 }
 
+void TargetLowering::emitConstants(GlobalContext *Ctx) {
+  // Wait for the worker threads to finish so that we know nothing
+  // more will be added to the constant pool.
+  Ctx->waitForWorkerThreads();

[JF, 2015/01/22 20:50:56]

It seems somewhat obscure to have emitConstants be the one that blocks and waits
for the worker threads. I'd instead have a higher level function which starts
the threads, enqueues work, waits for the threads, and then emits constants and
others.

[jvoung (off chromium), 2015/01/22 23:06:06]

Looks like it should have already been done before this, so this one is
redundant?

   void ExitBlock() override {
     InstallGlobalNamesAndGlobalVarInitializers();
+    getTranslator().getContext()->waitForWorkerThreads();
     getTranslator().emitConstants();
   }

[Jim Stichnoth, 2015/01/23 07:55:55]

Done, in main(), so that startWorkerThreads() and waitForWorkerThreads()
brackets the translation.

[Jim Stichnoth, 2015/01/23 07:55:55]

Done.

+  if (Ctx->getFlags().DisableTranslation)
+    return;
+  TargetArch Target = Ctx->getTargetArch();
+  if (Target == Target_X8632) {
+    TargetX8632::emitConstants(Ctx);
+    return;
+  }
+#if 0
+  if (Target == Target_X8664) {
+    IceTargetX8664::emitConstants(Ctx);
+    return;
+  }
+  if (Target == Target_ARM32) {
+    IceTargetARM32::emitConstants(Ctx);
+    return;
+  }
+  if (Target == Target_ARM64) {
+    IceTargetARM64::emitConstants(Ctx);
+    return;
+  }
+#endif
+  llvm_unreachable("emitConstants: Unsupported target");
+}
+
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()),
       RandomizeRegisterAllocation(CLRandomizeRegisterAllocation),
       HasComputedFrame(false), CallsReturnsTwice(false), StackAdjustment(0),
       Context() {}
 
 std::unique_ptr<Assembler> TargetLowering::createAssembler(TargetArch Target,
                                                            Cfg *Func) {
   // These statements can be #ifdef'd to specialize the assembler
   // to a subset of the available targets.  TODO: use CRTP.
@@ skipping 153 matching lines @@
   if (Target == Target_ARM64)
     return IceTargetGlobalInitARM64::create(Ctx);
 #endif
   llvm_unreachable("Unsupported target");
   return nullptr;
 }
 
 TargetGlobalInitLowering::~TargetGlobalInitLowering() {}
 
 } // end of namespace Ice