Reduce wait times for very large PEXE files.

src/IceGlobalContext.cpp

@@ -289,15 +289,25 @@ void GlobalContext::CodeStats::dump(const Cfg *Func, GlobalContext *Ctx) {
   }
 }
 
+namespace {
+
+// By default, wake up the main parser thread when the OptQ gets half empty.
+static constexpr size_t DefaultOptQWakeupSize = GlobalContext::MaxOptQSize >> 1;
+
+} // end of anonymous namespace
+
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
                              ELFStreamer *ELFStr)
     : Strings(new StringPool()), ConstPool(new ConstantPool()), ErrorStatus(),
       StrDump(OsDump), StrEmit(OsEmit), StrError(OsError), IntrinsicsInfo(this),
-      ObjectWriter(), OptQ(/*Sequential=*/getFlags().isSequential(),
-                           /*MaxSize=*/
-                           getFlags().isParseParallel()
-                               ? MaxOptQSize
-                               : getFlags().getNumTranslationThreads()),
+      ObjectWriter(),
+      OptQWakeupSize(std::max(DefaultOptQWakeupSize,
+                              size_t(getFlags().getNumTranslationThreads()))),
+      OptQ(/*Sequential=*/getFlags().isSequential(),
+           /*MaxSize=*/
+           getFlags().isParseParallel()
+               ? MaxOptQSize
+               : getFlags().getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/getFlags().isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)) {
@@ -939,7 +949,7 @@ void GlobalContext::optQueueBlockingPush(std::unique_ptr<OptWorkItem> Item) {
 
 std::unique_ptr<OptWorkItem> GlobalContext::optQueueBlockingPop() {
   TimerMarker _(TimerStack::TT_qTransPop, this);
-  return std::unique_ptr<OptWorkItem>(OptQ.blockingPop());
+  return OptQ.blockingPop(OptQWakeupSize);
 }
 
 void GlobalContext::emitQueueBlockingPush(

src/IceGlobalContext.h

@@ -477,6 +477,11 @@ public:
     return LockedPtr<StringPool>(Strings.get(), &StringsLock);
   }
 
+  /// Number of function blocks that can be queued before waiting for
+  /// translation
+  /// threads to consume.
+  static constexpr size_t MaxOptQSize = 1 << 16;
+
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
@@ -543,7 +548,8 @@ private:
   Intrinsics IntrinsicsInfo;
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
-  static constexpr size_t MaxOptQSize = 1 << 16;
+  // Value defining when to wake up the main parse thread.
+  const size_t OptQWakeupSize;
   BoundedProducerConsumerQueue<OptWorkItem, MaxOptQSize> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
   // DataLowering is only ever used by a single thread at a time (either in

src/IceThreading.h

@@ -67,7 +67,7 @@ public:
     }
     GrewOrEnded.notify_one();
   }
-  std::unique_ptr<T> blockingPop() {
+  std::unique_ptr<T> blockingPop(size_t NotifyWhenDownToSize = MaxStaticSize) {
     std::unique_ptr<T> Item;
     bool ShouldNotifyProducer = false;
     {
@@ -75,7 +75,7 @@ public:
       GrewOrEnded.wait(L, [this] { return IsEnded || !empty() || Sequential; });
       if (!empty()) {
         Item = pop();
-        ShouldNotifyProducer = !IsEnded;
+        ShouldNotifyProducer = (size() < NotifyWhenDownToSize) && !IsEnded;
       }
     }
     if (ShouldNotifyProducer)