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
 // multiple functions.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALCONTEXT_H
 #define SUBZERO_SRC_ICEGLOBALCONTEXT_H
 
+#include <array>
 #include <mutex>
 #include <thread>
 
 #include "IceDefs.h"
 #include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 #include "IceUtils.h"
@@ skipping 27 matching lines @@
 };
 
 class GlobalContext {
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
 
   // CodeStats collects rudimentary statistics during translation.
   class CodeStats {
     CodeStats(const CodeStats &) = delete;
     CodeStats &operator=(const CodeStats &) = default;
+#define CODESTATS_TABLE                                                        \
+  /* dump string, enum value */                                                \
+  X("Inst Count  ", InstCount)                                                 \
+  X("Regs Saved  ", RegsSaved)                                                 \
+  X("Frame Bytes ", FrameByte)                                                 \
+  X("Spills      ", NumSpills)                                                 \
+  X("Fills       ", NumFills)
+    //#define X(str, tag)
 
   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; }
+    enum CSTag {
+#define X(str, tag) CS_##tag,
+      CODESTATS_TABLE
+#undef X
+          CS_NUM
+    };
+    CodeStats() { reset(); }
+    void reset() { Stats.fill(0); }
+    void update(CSTag Tag, uint32_t Count = 1) {
+      assert(Tag < Stats.size());
+      Stats[Tag] += Count;
+    }
+    void add(const CodeStats &Other) {
+      for (uint32_t i = 0; i < Stats.size(); ++i)
+        Stats[i] += Other.Stats[i];
+    }
     void dump(const IceString &Name, Ostream &Str);
 
   private:
-    uint32_t InstructionsEmitted;
-    uint32_t RegistersSaved;
-    uint32_t FrameBytes;
-    uint32_t Spills;
-    uint32_t Fills;
+    std::array<uint32_t, CS_NUM> Stats;
   };
 
   // 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);
+    ThreadContext *TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.update(CodeStats::CS_InstCount, InstCount);
+    TLS->StatsCumulative.update(CodeStats::CS_InstCount, InstCount);
   }
   void statsUpdateRegistersSaved(uint32_t Num) {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateRegistersSaved(Num);
-    getStatsCumulative()->updateRegistersSaved(Num);
+    ThreadContext *TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.update(CodeStats::CS_RegsSaved, Num);
+    TLS->StatsCumulative.update(CodeStats::CS_RegsSaved, Num);
   }
   void statsUpdateFrameBytes(uint32_t Bytes) {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateFrameBytes(Bytes);
-    getStatsCumulative()->updateFrameBytes(Bytes);
+    ThreadContext *TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.update(CodeStats::CS_FrameByte, Bytes);
+    TLS->StatsCumulative.update(CodeStats::CS_FrameByte, Bytes);
   }
   void statsUpdateSpills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateSpills();
-    getStatsCumulative()->updateSpills();
+    ThreadContext *TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.update(CodeStats::CS_NumSpills);
+    TLS->StatsCumulative.update(CodeStats::CS_NumSpills);
   }
   void statsUpdateFills() {
     if (!ALLOW_DUMP || !getFlags().DumpStats)
       return;
-    ICE_TLS_GET_FIELD(TLS)->StatsFunction.updateFills();
-    getStatsCumulative()->updateFills();
+    ThreadContext *TLS = ICE_TLS_GET_FIELD(TLS);
+    TLS->StatsFunction.update(CodeStats::CS_NumFills);
+    TLS->StatsCumulative.update(CodeStats::CS_NumFills);
   }
 
   // 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