Subzero: Fix stats collection and output for multithreading.

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 55 matching lines @@
   public:
     CodeStats()
         : InstructionsEmitted(0), RegistersSaved(0), FrameBytes(0), Spills(0),
           Fills(0) {}
     void reset() { *this = CodeStats(); }
     void updateEmitted(uint32_t InstCount) { InstructionsEmitted += InstCount; }
     void updateRegistersSaved(uint32_t Num) { RegistersSaved += Num; }
     void updateFrameBytes(uint32_t Bytes) { FrameBytes += Bytes; }
     void updateSpills() { ++Spills; }
     void updateFills() { ++Fills; }
+    void add(const CodeStats &Other) {
+      InstructionsEmitted += Other.InstructionsEmitted;
+      RegistersSaved += Other.RegistersSaved;
+      FrameBytes += Other.FrameBytes;
+      Spills += Other.Spills;
+      Fills += Other.Fills;
+    }
     void dump(const IceString &Name, Ostream &Str);
 
   private:
     uint32_t InstructionsEmitted;
     uint32_t RegistersSaved;
     uint32_t FrameBytes;
     uint32_t Spills;
     uint32_t Fills;

[JF, 2015/01/31 05:48:38]

X-macros for these, and add(), and the update*() methods?

[Jim Stichnoth, 2015/01/31 16:42:28]

Done.

   };
 
   // TimerList is a vector of TimerStack objects, with extra methods
   // to initialize and merge these vectors.
   class TimerList : public std::vector<TimerStack> {
   public:
     // initInto() initializes a target list of timers based on the
     // current list.  In particular, it creates the same number of
     // timers, in the same order, with the same names, but initially
     // empty of timing data.
@@ skipping 20 matching lines @@
 
   // ThreadContext contains thread-local data.  This data can be
   // combined/reduced as needed after all threads complete.
   class ThreadContext {
     ThreadContext(const ThreadContext &) = delete;
     ThreadContext &operator=(const ThreadContext &) = delete;
 
   public:
     ThreadContext() {}
     CodeStats StatsFunction;
+    CodeStats StatsCumulative;
     TimerList Timers;
   };
 
 public:
   GlobalContext(Ostream *OsDump, Ostream *OsEmit, ELFStreamer *ELFStreamer,
                 VerboseMask Mask, TargetArch Arch, OptLevel Opt,
                 IceString TestPrefix, const ClFlags &Flags);
   ~GlobalContext();
 
   VerboseMask getVerbose() const { return VMask; }
@@ skipping 68 matching lines @@
 
   // Reset stats at the beginning of a function.
   void resetStats() {
     if (ALLOW_DUMP)
       ICE_TLS_GET_FIELD(TLS)->StatsFunction.reset();
   }
   void dumpStats(const IceString &Name, bool Final = false);
   void statsUpdateEmitted(uint32_t InstCount) {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateEmitted(InstCount);
-    getStatsCumulative()->updateEmitted(InstCount);
+    auto TLS = ICE_TLS_GET_FIELD(TLS);

[JF, 2015/01/31 05:48:38]

auto *TLS = ...;

[Jim Stichnoth, 2015/01/31 16:42:28]

Done, took it one step further...

My original idea was that when we eventually get rid of these ICE_TLS macros,
this initialization would reduce to "auto TLS = TLS;" and ultimately be removed
entirely without any surrounding code modifications, so using the simplest
possible "auto" initialization would make it easier to come to that conclusion. 
But, that's probably overthinking it so I put back the full declaration.

+    TLS->StatsFunction.updateEmitted(InstCount);
+    TLS->StatsCumulative.updateEmitted(InstCount);
   }
   void statsUpdateRegistersSaved(uint32_t Num) {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateRegistersSaved(Num);
-    getStatsCumulative()->updateRegistersSaved(Num);
+    auto TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.updateRegistersSaved(Num);
+    TLS->StatsCumulative.updateRegistersSaved(Num);
   }
   void statsUpdateFrameBytes(uint32_t Bytes) {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateFrameBytes(Bytes);
-    getStatsCumulative()->updateFrameBytes(Bytes);
+    auto TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.updateFrameBytes(Bytes);
+    TLS->StatsCumulative.updateFrameBytes(Bytes);
   }
   void statsUpdateSpills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateSpills();
-    getStatsCumulative()->updateSpills();
+    auto TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.updateSpills();
+    TLS->StatsCumulative.updateSpills();
   }
   void statsUpdateFills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateFills();
-    getStatsCumulative()->updateFills();
+    auto TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.updateFills();
+    TLS->StatsCumulative.updateFills();
   }
 
   // These are predefined TimerStackIdT values.
   enum TimerStackKind { TSK_Default = 0, TSK_Funcs, TSK_Num };
 
   // newTimerStackID() creates a new TimerStack in the global space.
   // It does not affect any TimerStack objects in TLS.
   TimerStackIdT newTimerStackID(const IceString &Name);
   // dumpTimers() dumps the global timer data.  As such, one probably
   // wants to call mergeTimerStacks() as a prerequisite.
@@ skipping 41 matching lines @@
     for (std::thread &Worker : TranslationThreads) {
       Worker.join();
     }
     TranslationThreads.clear();
     // TODO(stichnot): join the emitter thread.
     if (ALLOW_DUMP) {
       auto Timers = getTimers();
       for (ThreadContext *TLS : AllThreadContexts)
         Timers->mergeFrom(TLS->Timers);
     }
+    if (ALLOW_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);
+    }
   }
 
   // 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();
 
@@ skipping 130 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