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(""), NumTimerStackIds(0) {
+  // Pre-register built-in stack names.
+  newTimerStackID("Total across all functions");
+  newTimerStackID("Per-function summary");
+}
 
 // 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 241 matching lines @@
     BaseOS << "Unsupported constant type: " << Ty;
     llvm_unreachable(BaseOS.str().c_str());
   } break;
   case IceType_void:
   case IceType_NUM:
     break;
   }
   llvm_unreachable("Unknown type");
 }
 
-TimerIdT GlobalContext::getTimerID(const IceString &Name) {
-  return TimerStack::getTimerID(Name);
+TimerIdT GlobalContext::getTimerID(TimerStackIdT StackID,
+                                   const IceString &Name) {
+  assert(StackID < Timers.size());
+  return Timers[StackID].getTimerID(Name);
 }
 
-void GlobalContext::pushTimer(TimerIdT ID) { Timers->push(ID); }
+TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
+  Timers.push_back(TimerStack(Name));
+  return NumTimerStackIds++;

[jvoung (off chromium), 2014/10/06 23:01:52]

Could this just use Timers.size() (or return void)?

[Jim Stichnoth, 2014/10/06 23:54:39]

Done (and removed the NumTimerStackIds field entirely).

In the imagined future use, the caller would actually save the return value and
use it for the pushTimer and popTimer calls.

+}
 
-void GlobalContext::popTimer(TimerIdT ID) { Timers->pop(ID); }
+void GlobalContext::pushTimer(TimerIdT ID, TimerStackIdT StackID) {
+  assert(StackID < Timers.size());
+  Timers[StackID].push(ID);
+}
+
+void GlobalContext::popTimer(TimerIdT ID, TimerStackIdT StackID) {
+  assert(StackID < Timers.size());
+  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);
+}
+
+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