Subzero: Add a few performance measurement tools.

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 <memory>
 
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include "IceDefs.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
+#include "IceTimerTree.h"
 #include "IceTypes.h"
 
 namespace Ice {
 
 class ClFlags;
 
 // This class collects rudimentary statistics during translation.
 class CodeStats {
 public:
   CodeStats()
@@ skipping 28 matching lines @@
 class GlobalContext {
 public:
   GlobalContext(llvm::raw_ostream *OsDump, llvm::raw_ostream *OsEmit,
                 VerboseMask Mask, TargetArch Arch, OptLevel Opt,
                 IceString TestPrefix, const ClFlags &Flags);
   ~GlobalContext();
 
   // Returns true if any of the specified options in the verbose mask
   // are set.  If the argument is omitted, it checks if any verbose
   // options at all are set.
+  VerboseMask getVerbose() const { return VMask; }
   bool isVerbose(VerboseMask Mask = IceV_All) const { return VMask & Mask; }
   void setVerbose(VerboseMask Mask) { VMask = Mask; }
   void addVerbose(VerboseMask Mask) { VMask |= Mask; }
   void subVerbose(VerboseMask Mask) { VMask &= ~Mask; }
 
   Ostream &getStrDump() { return *StrDump; }
   Ostream &getStrEmit() { return *StrEmit; }
 
   TargetArch getTargetArch() const { return Arch; }
   OptLevel getOptLevel() const { return Opt; }
@@ skipping 60 matching lines @@
   }
   void statsUpdateSpills() {
     StatsFunction.updateSpills();
     StatsCumulative.updateSpills();
   }
   void statsUpdateFills() {
     StatsFunction.updateFills();
     StatsCumulative.updateFills();
   }
 
+  // These are predefined TimerStackIdT values.
+  enum TimerStackKind {
+    TSK_Default = 0,
+    TSK_Funcs,
+    TSK_Num
+  };
+
   static TimerIdT getTimerID(const IceString &Name);
-  void pushTimer(TimerIdT ID);
-  void popTimer(TimerIdT ID);
-  void dumpTimers();
+  static TimerStackIdT getTimerStackID();

[jvoung (off chromium), 2014/10/06 16:30:56]

How is getTimerStackID() planned to be used? (I don't see a user in this patch
set)

At first I thought there was a new timerstackid per function, but it looks like
it's a separate timer ID instead (using the function name).

[Jim Stichnoth, 2014/10/06 21:29:57]

The thought is that some component, e.g. the bitcode parser, could use this
along with instrumenting its own code.  The advantage is that it's easily
accessible through the GlobalContext object.

BTW, I changed this to be non-static, and the GlobalContext ctor uses it to
pre-allocate the two predefined timer stacks.

+  void pushTimer(TimerIdT ID, TimerStackIdT StackID = TSK_Default);
+  void popTimer(TimerIdT ID, TimerStackIdT StackID = TSK_Default);
+  void dumpTimers(TimerStackIdT StackID = TSK_Default,
+                  bool DumpCumulative = true);
 
 private:
   Ostream *StrDump; // Stream for dumping / diagnostics
   Ostream *StrEmit; // Stream for code emission
 
   llvm::BumpPtrAllocator Allocator;
   VerboseMask VMask;
   std::unique_ptr<class ConstantPool> ConstPool;
   Intrinsics IntrinsicsInfo;
   const TargetArch Arch;
   const OptLevel Opt;
   const IceString TestPrefix;
   const ClFlags &Flags;
   bool HasEmittedFirstMethod;
   RandomNumberGenerator RNG;
   CodeStats StatsFunction;
   CodeStats StatsCumulative;
-  std::unique_ptr<class TimerStack> Timers;
+  std::vector<TimerStack> Timers;
+  static TimerStackIdT NumTimerStackIds;
   GlobalContext(const GlobalContext &) = delete;
   GlobalContext &operator=(const GlobalContext &) = delete;
 
   // Private helpers for mangleName()
   typedef llvm::SmallVector<char, 32> ManglerVector;
   void incrementSubstitutions(ManglerVector &OldName) const;
 };
 
 // Helper class to push and pop a timer marker.  The constructor
 // pushes a marker, and the destructor pops it.  This is for
 // convenient timing of regions of code.
 class TimerMarker {
   TimerMarker(const TimerMarker &) = delete;
   TimerMarker &operator=(const TimerMarker &) = delete;
 
 public:
   TimerMarker(TimerIdT ID, GlobalContext *Ctx)
       : ID(ID), Ctx(Ctx), Active(Ctx->getFlags().SubzeroTimingEnabled) {
     if (Active)
       Ctx->pushTimer(ID);
   }
+  TimerMarker(TimerIdT ID, const Cfg *Func);
+
   ~TimerMarker() {
     if (Active)
       Ctx->popTimer(ID);
   }
 
 private:
   TimerIdT ID;
   GlobalContext *const Ctx;
   const bool Active;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H