Allow Subzero to parse function blocks in parallel.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 59 matching lines @@
   ~LockedPtr() { Lock->unlock(); }
   T *operator->() const { return Value; }
   T &operator*() const { return *Value; }
   T *get() { return Value; }
 
 private:
   T *Value;
   GlobalLockType *Lock;
 };
 
+/// OptWorkItem is a simple wrapper used to pass parse information on a function
+/// block, to a translator thread.
+class OptWorkItem {
+  OptWorkItem(const OptWorkItem &) = delete;
+  OptWorkItem &operator=(const OptWorkItem &) = delete;
+
+public:
+  // Get the Cfg for the funtion to translate.
+  virtual std::unique_ptr<Cfg> getParsedCfg() = 0;
+  virtual ~OptWorkItem() {}
+
+protected:
+  OptWorkItem() {}

[Jim Stichnoth, 2016/03/25 04:31:04]

OptWorkItem() = default;
?

Same for ~OptWorkItem() ?

[Karl, 2016/03/29 17:35:02]

Done.

+};
+
 class GlobalContext {
   GlobalContext() = delete;
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
 
   /// CodeStats collects rudimentary statistics during translation.
   class CodeStats {
     CodeStats(const CodeStats &) = delete;
     CodeStats &operator=(const CodeStats &) = default;
 #define CODESTATS_TABLE                                                        \
@@ skipping 281 matching lines @@
   /// This is the first work item sequence number that the parser produces, and
   /// correspondingly the first sequence number that the emitter thread will
   /// wait for. Start numbering at 1 to leave room for a sentinel, in case e.g.
   /// we wish to inject items with a special sequence number that may be
   /// executed out of order.
   static uint32_t getFirstSequenceNumber() { return 1; }
   /// Adds a newly parsed and constructed function to the Cfg work queue.
   /// Notifies any idle workers that a new function is available for
   /// translating. May block if the work queue is too large, in order to control
   /// memory footprint.
-  void optQueueBlockingPush(std::unique_ptr<Cfg> Func);
+  void optQueueBlockingPush(std::unique_ptr<OptWorkItem> Item);
   /// Takes a Cfg from the work queue for translating. May block if the work
   /// queue is currently empty. Returns nullptr if there is no more work - the
   /// queue is empty and either end() has been called or the Sequential flag was
   /// set.
-  std::unique_ptr<Cfg> optQueueBlockingPop();
+  std::unique_ptr<OptWorkItem> optQueueBlockingPop();
   /// Notifies that no more work will be added to the work queue.
   void optQueueNotifyEnd() { OptQ.notifyEnd(); }
 
   /// Emit file header for output file.
   void emitFileHeader();
 
   void lowerConstants();
 
   void lowerJumpTables();
 
@@ skipping 21 matching lines @@
     }
     if (NumWorkers) {
       ThreadContext *WorkerTLS = new ThreadContext();
       Timers->initInto(WorkerTLS->Timers);
       AllThreadContexts.push_back(WorkerTLS);
       EmitterThreads.push_back(
           std::thread(&GlobalContext::emitterWrapper, this, WorkerTLS));
     }
   }
 
-  void waitForWorkerThreads() {
-    optQueueNotifyEnd();
-    for (std::thread &Worker : TranslationThreads) {
-      Worker.join();
-    }
-    TranslationThreads.clear();
-
-    // Only notify the emit queue to end after all the translation threads have
-    // ended.
-    emitQueueNotifyEnd();
-    for (std::thread &Worker : EmitterThreads) {
-      Worker.join();
-    }
-    EmitterThreads.clear();
-
-    if (BuildDefs::timers()) {
-      auto Timers = getTimers();
-      for (ThreadContext *TLS : AllThreadContexts)
-        Timers->mergeFrom(TLS->Timers);
-    }
-    if (BuildDefs::dump()) {
-      // Do a separate loop over AllThreadContexts to avoid holding two locks
-      // at once.
-      auto Stats = getStatsCumulative();
-      for (ThreadContext *TLS : AllThreadContexts)
-        Stats->add(TLS->StatsCumulative);
-    }
-  }
+  void waitForWorkerThreads();
 
   /// Translation thread startup routine.
   void translateFunctionsWrapper(ThreadContext *MyTLS) {
     ICE_TLS_SET_FIELD(TLS, MyTLS);
     translateFunctions();
   }
   /// Translate functions from the Cfg queue until the queue is empty.
   void translateFunctions();
 
   /// Emitter thread startup routine.
@@ skipping 86 matching lines @@
 
   ICE_CACHELINE_BOUNDARY;
   /// StrLock is a global lock on the dump and emit output streams.
   using StrLockType = std::mutex;
   StrLockType StrLock;
   Ostream *StrDump;  /// Stream for dumping / diagnostics
   Ostream *StrEmit;  /// Stream for code emission
   Ostream *StrError; /// Stream for logging errors.
 
   ICE_CACHELINE_BOUNDARY;
+  // WaitForWorkersLock is a global lock used to update
+  // WaitForWorkerThreadsCalled.
+  GlobalLockType WaitForWorkersLock;
+  // True if WaitForWorkerThreads have been called.

[Jim Stichnoth, 2016/03/25 04:31:04]

True if waitForWorkerThreads() has been called.

[Karl, 2016/03/29 17:35:02]

Done.

+  bool WaitForWorkerThreadsCalled = false;
+
+  ICE_CACHELINE_BOUNDARY;
 
   Intrinsics IntrinsicsInfo;
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
-  BoundedProducerConsumerQueue<Cfg> OptQ;
+  static constexpr size_t MaxOptQSize = 1 << 16;
+  BoundedProducerConsumerQueue<OptWorkItem, MaxOptQSize> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
   // DataLowering is only ever used by a single thread at a time (either in
   // emitItems(), or in IceCompiler::run before the compilation is over.)
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<TargetDataLowering> DataLowering;
   /// If !HasEmittedCode, SubZero will accumulate all Globals (which are "true"
   /// program global variables) until the first code WorkItem is seen.
   // TODO(jpp): move to EmitterContext.
   bool HasSeenCode = false;
   // TODO(jpp): move to EmitterContext.
@@ skipping 120 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H