Subzero. Uses unique_ptrs in the emit queue.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 301 matching lines @@
     // translation is disabled, just dump the high-level IR and
     // continue.
     if (getFlags().getDisableTranslation() ||
         !matchSymbolName(Func->getFunctionName(),
                          getFlags().getTranslateOnly())) {
       Func->dump();
       continue; // Func goes out of scope and gets deleted
     }
 
     Func->translate();
-    EmitterWorkItem *Item = nullptr;
+    std::unique_ptr<EmitterWorkItem> Item;
     if (Func->hasError()) {
       getErrorStatus()->assign(EC_Translation);
       OstreamLocker L(this);
       getStrError() << "ICE translation error: " << Func->getFunctionName()
                     << ": " << Func->getError() << ": "
                     << Func->getFunctionNameAndSize() << "\n";
-      Item = new EmitterWorkItem(Func->getSequenceNumber());
+      Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber());
     } else {
       Func->getAssembler<>()->setInternal(Func->getInternal());
       switch (getFlags().getOutFileType()) {
       case FT_Elf:
       case FT_Iasm: {
         Func->emitIAS();
         // The Cfg has already emitted into the assembly buffer, so
         // stats have been fully collected into this thread's TLS.
         // Dump them before TLS is reset for the next Cfg.
         dumpStats(Func->getFunctionNameAndSize());
-        Assembler *Asm = Func->releaseAssembler();
+        auto Asm = Func->releaseAssembler();
         // Copy relevant fields into Asm before Func is deleted.
         Asm->setFunctionName(Func->getFunctionName());
-        Item = new EmitterWorkItem(Func->getSequenceNumber(), Asm);
+        Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber(),
+                                           std::move(Asm));
         Item->setGlobalInits(Func->getGlobalInits());
       } break;
       case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
         std::unique_ptr<VariableDeclarationList> GlobalInits =
             Func->getGlobalInits();
-        Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
+        Item = makeUnique<EmitterWorkItem>(Func->getSequenceNumber(),
+                                           std::move(Func));
         Item->setGlobalInits(std::move(GlobalInits));
         break;
       }
     }
-    assert(Item);
-    emitQueueBlockingPush(Item);
+    assert(Item != nullptr);
+    emitQueueBlockingPush(std::move(Item));
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
 // Ensure Pending is large enough that Pending[Index] is valid.
-void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
-  if (Index >= Pending.size())
-    Utils::reserveAndResize(Pending, Index + 1);
+void resizePending(std::vector<std::unique_ptr<EmitterWorkItem>> *Pending,
+                   uint32_t Index) {
+  if (Index >= Pending->size())
+    Utils::reserveAndResize(*Pending, Index + 1);
 }
 
 } // end of anonymous namespace
 
 void GlobalContext::emitFileHeader() {
   TimerMarker T1(Ice::TimerStack::TT_emitAsm, this);
   if (getFlags().getOutFileType() == FT_Elf) {
     getObjectWriter()->writeInitialELFHeader();
   } else {
     if (!BuildDefs::dump()) {
@@ skipping 86 matching lines @@
 }
 
 void GlobalContext::emitItems() {
   const bool Threaded = !getFlags().isSequential();
   // Pending is a vector containing the reassembled, ordered list of
   // work items.  When we're ready for the next item, we first check
   // whether it's in the Pending list.  If not, we take an item from
   // the work queue, and if it's not the item we're waiting for, we
   // insert it into Pending and repeat.  The work item is deleted
   // after it is processed.
-  std::vector<EmitterWorkItem *> Pending;
+  std::vector<std::unique_ptr<EmitterWorkItem>> Pending;
   uint32_t DesiredSequenceNumber = getFirstSequenceNumber();
   uint32_t ShuffleStartIndex = DesiredSequenceNumber;
   uint32_t ShuffleEndIndex = DesiredSequenceNumber;
   bool EmitQueueEmpty = false;
   const uint32_t ShuffleWindowSize =
       std::max(1u, getFlags().getReorderFunctionsWindowSize());
   bool Shuffle = Threaded && getFlags().shouldReorderFunctions();
   // Create a random number generator for function reordering.
   RandomNumberGenerator RNG(getFlags().getRandomSeed(), RPE_FunctionReordering);
 
   while (!EmitQueueEmpty) {
-    resizePending(Pending, DesiredSequenceNumber);
+    resizePending(&Pending, DesiredSequenceNumber);
     // See if Pending contains DesiredSequenceNumber.
-    EmitterWorkItem *RawItem = Pending[DesiredSequenceNumber];
-    if (RawItem == nullptr) {
+    if (Pending[DesiredSequenceNumber] == nullptr) {
       // We need to fetch an EmitterWorkItem from the queue.
-      RawItem = emitQueueBlockingPop();
+      auto RawItem = emitQueueBlockingPop();
       if (RawItem == nullptr) {
         // This is the notifier for an empty queue.
         EmitQueueEmpty = true;
       } else {
         // We get an EmitterWorkItem, we need to add it to Pending.
         uint32_t ItemSeq = RawItem->getSequenceNumber();
         if (Threaded && ItemSeq != DesiredSequenceNumber) {
           // Not the desired one, add it to Pending but do not increase
           // DesiredSequenceNumber. Continue the loop, do not emit the item.
-          resizePending(Pending, ItemSeq);
-          Pending[ItemSeq] = RawItem;
+          resizePending(&Pending, ItemSeq);
+          Pending[ItemSeq] = std::move(RawItem);
           continue;
         }
         // ItemSeq == DesiredSequenceNumber, we need to check if we should
         // emit it or not. If !Threaded, we're OK with ItemSeq !=
         // DesiredSequenceNumber.
-        Pending[DesiredSequenceNumber] = RawItem;
+        Pending[DesiredSequenceNumber] = std::move(RawItem);
       }
     }
+    const auto *CurrentWorkItem = Pending[DesiredSequenceNumber].get();
+
     // We have the desired EmitterWorkItem or nullptr as the end notifier.
     // If the emitter queue is not empty, increase DesiredSequenceNumber and
     // ShuffleEndIndex.
     if (!EmitQueueEmpty) {
       DesiredSequenceNumber++;
       ShuffleEndIndex++;
     }
 
     if (Shuffle) {
       // Continue fetching EmitterWorkItem if function reordering is turned on,
       // and emit queue is not empty, and the number of consecutive pending
       // items is smaller than the window size, and RawItem is not a
       // WI_GlobalInits kind. Emit WI_GlobalInits kind block first to avoid
       // holding an arbitrarily large GlobalDeclarationList.
       if (!EmitQueueEmpty &&
           ShuffleEndIndex - ShuffleStartIndex < ShuffleWindowSize &&
-          RawItem->getKind() != EmitterWorkItem::WI_GlobalInits)
+          CurrentWorkItem->getKind() != EmitterWorkItem::WI_GlobalInits)
         continue;
 
       // Emit the EmitterWorkItem between Pending[ShuffleStartIndex] to
       // Pending[ShuffleEndIndex]. If function reordering turned on, shuffle the
       // pending items from Pending[ShuffleStartIndex] to
       // Pending[ShuffleEndIndex].
       RandomShuffle(Pending.begin() + ShuffleStartIndex,
                     Pending.begin() + ShuffleEndIndex,
                     [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
     }
 
     // Emit the item from ShuffleStartIndex to ShuffleEndIndex.
     for (uint32_t I = ShuffleStartIndex; I < ShuffleEndIndex; I++) {
-      std::unique_ptr<EmitterWorkItem> Item(Pending[I]);
+      std::unique_ptr<EmitterWorkItem> Item = std::move(Pending[I]);
 
       switch (Item->getKind()) {
       case EmitterWorkItem::WI_Nop:
         break;
       case EmitterWorkItem::WI_GlobalInits: {
         accumulateGlobals(Item->getGlobalInits());
       } break;
       case EmitterWorkItem::WI_Asm: {
         lowerGlobalsIfNoCodeHasBeenSeen();
         accumulateGlobals(Item->getGlobalInits());
@@ skipping 303 matching lines @@
 }
 
 // Note: optQueueBlockingPush and optQueueBlockingPop use unique_ptr at the
 // interface to take and transfer ownership, but they internally store the raw
 // Cfg pointer in the work queue. This allows e.g. future queue optimizations
 // such as the use of atomics to modify queue elements.
 void GlobalContext::optQueueBlockingPush(std::unique_ptr<Cfg> Func) {
   assert(Func);
   {
     TimerMarker _(TimerStack::TT_qTransPush, this);
-    OptQ.blockingPush(Func.release());
+    OptQ.blockingPush(std::move(Func));
   }
   if (getFlags().isSequential())
     translateFunctions();
 }
 
 std::unique_ptr<Cfg> GlobalContext::optQueueBlockingPop() {
   TimerMarker _(TimerStack::TT_qTransPop, this);
   return std::unique_ptr<Cfg>(OptQ.blockingPop());
 }
 
-void GlobalContext::emitQueueBlockingPush(EmitterWorkItem *Item) {
+void GlobalContext::emitQueueBlockingPush(
+    std::unique_ptr<EmitterWorkItem> Item) {
   assert(Item);
   {
     TimerMarker _(TimerStack::TT_qEmitPush, this);
-    EmitQ.blockingPush(Item);
+    EmitQ.blockingPush(std::move(Item));
   }
   if (getFlags().isSequential())
     emitItems();
 }
 
-EmitterWorkItem *GlobalContext::emitQueueBlockingPop() {
+std::unique_ptr<EmitterWorkItem> GlobalContext::emitQueueBlockingPop() {
   TimerMarker _(TimerStack::TT_qEmitPop, this);
   return EmitQ.blockingPop();
 }
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (!getFlags().getDumpStats())
     return;
   if (Final) {
     getStatsCumulative()->dump(Name, this);
   } else {
@@ skipping 41 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice