Subzero: Add a few performance measurement tools.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines aspects of the compilation that persist across
@@ skipping 101 matching lines @@
   UndefPool Undefs;
 };
 
 GlobalContext::GlobalContext(llvm::raw_ostream *OsDump,
                              llvm::raw_ostream *OsEmit, VerboseMask Mask,
                              TargetArch Arch, OptLevel Opt,
                              IceString TestPrefix, const ClFlags &Flags)
     : StrDump(OsDump), StrEmit(OsEmit), VMask(Mask),
       ConstPool(new ConstantPool()), Arch(Arch), Opt(Opt),
       TestPrefix(TestPrefix), Flags(Flags), HasEmittedFirstMethod(false),
-      RNG(""), Timers(new TimerStack("main")) {}
+      RNG("") {}
 
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
 // following substitution string like "S1_" or "PS1_" may be combined
@@ skipping 245 matching lines @@
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
 TimerIdT GlobalContext::getTimerID(const IceString &Name) {
   return TimerStack::getTimerID(Name);
 }
 
-void GlobalContext::pushTimer(TimerIdT ID) { Timers->push(ID); }
+TimerStackIdT GlobalContext::NumTimerStackIds = GlobalContext::TSK_Num;
 
-void GlobalContext::popTimer(TimerIdT ID) { Timers->pop(ID); }
+TimerStackIdT GlobalContext::getTimerStackID() { return NumTimerStackIds++; }
+
+void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
+  if (Timers.size() <= StackID)
+    Timers.resize(StackID + 1);
+  Timers[StackID].push(ID);
+}
+
+void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
+  assert(Timers.size() > StackID);
+  Timers[StackID].pop(ID);
+}
 
 void GlobalContext::dumpStats(const IceString &Name, bool Final) {
   if (Flags.DumpStats) {
     if (Final) {
       StatsCumulative.dump(Name, getStrDump());
     } else {
       StatsFunction.dump(Name, getStrDump());
       StatsCumulative.dump("_TOTAL_", getStrDump());
     }
   }
 }
 
-void GlobalContext::dumpTimers() { Timers->dump(getStrDump()); }
+void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
+  assert(Timers.size() > StackID);
+  Timers[StackID].dump(getStrDump(), DumpCumulative);

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

Maybe the dump() can indicate which StackID the dump is for? Right now it should
be obvious which stack it's for though, based on the timer names (pass names vs
function names).

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

Done.

+}
+
+TimerMarker::TimerMarker(TimerIdT ID, const Cfg *Func)
+    : ID(ID), Ctx(Func->getContext()),
+      Active(Func->getFocusedTiming() || Ctx->getFlags().SubzeroTimingEnabled) {
+  if (Active)
+    Ctx->pushTimer(ID);
+}
 
 } // end of namespace Ice