Subzero: Manage each Cfg as a std::unique_ptr<Cfg>.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares aspects of the compilation that persist across
@@ skipping 259 matching lines @@
   TimerIdT getTimerID(TimerStackIdT StackID, const IceString &Name);
   void pushTimer(TimerIdT ID, TimerStackIdT StackID);
   void popTimer(TimerIdT ID, TimerStackIdT StackID);
   void resetTimer(TimerStackIdT StackID);
   void setTimerName(TimerStackIdT StackID, const IceString &NewName);
 
   // 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 cfgQueueBlockingPush(Cfg *Func) { CfgQ.blockingPush(Func); }

[Jim Stichnoth, 2015/02/02 16:51:15]

I've designed this such that the underlying queue contains raw Cfg pointers
rather than unique_ptr<Cfg> values.

1. This may allow a queue implementation involving atomics to insert/remove work
items to/from the queue.

2. The owner of the Cfg also has the Cfg installed in TLS for container arena
allocation.  Releasing the Cfg pointer from its unique_ptr should also remove it
from TLS.  I'm thinking maybe there should be a UniqueCfg class that wraps
unique_ptr<Cfg> and updates TLS on acquire and release.

[JF, 2015/02/02 17:11:47]

I'm not sure I understand, someone pushes by doing:
  cfgQueueBlockingPush(myPtr.release());

And pops with:
  unique_ptr<Cfg> myPtr = cfgQueueBlockingPop();

?

That's weirdly asymmetric. Push and pop should have the same API so that the
ownership is clear. The container can be raw pointers underneath, but as long as
I can see the unique_ptr going in and out then I can reliably say that there's
no leak and the ownership is clear.

In other words: unique_ptr goes in, unique_ptr goes out, you can't explain that.

[Jim Stichnoth, 2015/02/02 18:48:48]

Heh, I was afraid you'd catch that before I fixed it.

Done.

   // 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.
-  Cfg *cfgQueueBlockingPop() { return CfgQ.blockingPop(); }
+  std::unique_ptr<Cfg> cfgQueueBlockingPop();
   // Notifies that no more work will be added to the work queue.
   void cfgQueueNotifyEnd() { CfgQ.notifyEnd(); }
 
   void startWorkerThreads() {
     size_t NumWorkers = getFlags().NumTranslationThreads;
     auto Timers = getTimers();
     for (size_t i = 0; i < NumWorkers; ++i) {
       ThreadContext *WorkerTLS = new ThreadContext();
       Timers->initInto(WorkerTLS->Timers);
       AllThreadContexts.push_back(WorkerTLS);
@@ skipping 168 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