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;
   };
 
@@ skipping 28 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 69 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);
+    ICE_TLS_GET_FIELD(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);
+    ICE_TLS_GET_FIELD(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);
+    ICE_TLS_GET_FIELD(TLS)->StatsCumulative.updateFrameBytes(Bytes);
   }
   void statsUpdateSpills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateSpills();
-    getStatsCumulative()->updateSpills();
+    ICE_TLS_GET_FIELD(TLS)->StatsCumulative.updateSpills();
   }
   void statsUpdateFills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
     ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateFills();
-    getStatsCumulative()->updateFills();
+    ICE_TLS_GET_FIELD(TLS)->StatsCumulative.updateFills();

[JF, 2015/01/31 05:08:24]

Can you get the field only once per function instead of twice? I'm not sure the
compiler can eliminate redundant TLS fetches in all circumstances.

[Jim Stichnoth, 2015/01/31 05:36:59]

Nice, done.

   }
 
   // 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