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() {}
+};
+
 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 159 matching lines @@
   StrLockType StrLock;
   Ostream *StrDump;  /// Stream for dumping / diagnostics
   Ostream *StrEmit;  /// Stream for code emission
   Ostream *StrError; /// Stream for logging errors.
 
   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