Subzero: Add a few performance measurement tools.

src/IceTimerTree.cpp

 //===- subzero/src/IceTimerTree.cpp - Pass timer 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 the TimerTree class, which tracks flat and
 // cumulative execution time collection of call chains.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Timer.h"
 
 #include "IceDefs.h"
 #include "IceTimerTree.h"
 
 namespace Ice {
 
 std::vector<IceString> TimerStack::IDs;
 
-TimerStack::TimerStack(const IceString &TopLevelName)
+TimerStack::TimerStack()
     : FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp),
       StateChangeCount(0), StackTop(0) {
   Nodes.resize(1); // Reserve Nodes[0] for the root node.
-  push(getTimerID(TopLevelName));
 }
 
 // Returns the unique timer ID for the given Name, creating a new ID
 // if needed.  For performance reasons, it's best to make only one
 // call per Name and cache the result, e.g. via a static initializer.
 TimerIdT TimerStack::getTimerID(const IceString &Name) {
   TimerIdT Size = IDs.size();
   for (TimerIdT i = 0; i < Size; ++i) {
     if (IDs[i] == Name)
       return i;
@@ skipping 66 matching lines @@
   for (auto I = Map.rbegin(), E = Map.rend(); I != E; ++I) {
     char buf[80];
     snprintf(buf, llvm::array_lengthof(buf), "  %10.6f (%4.1f%%): ", I->first,
              I->first * 100 / TotalTime);
     Str << buf << I->second << "\n";
   }
 }
 
 } // end of anonymous namespace
 
-void TimerStack::dump(Ostream &Str) {
+void TimerStack::dump(Ostream &Str, bool DumpCumulative) {
   update();
   double TotalTime = LastTimestamp - FirstTimestamp;
   assert(TotalTime);
-  Str << "Cumulative function times:\n";
-  DumpMapType CumulativeMap;
-  for (TTindex i = 1; i < Nodes.size(); ++i) {
-    TTindex Prefix = i;
-    IceString Suffix = "";
-    while (Prefix) {
-      if (Suffix.empty())
-        Suffix = IDs[Nodes[Prefix].Interior];
-      else
-        Suffix = IDs[Nodes[Prefix].Interior] + "." + Suffix;
-      assert(Nodes[Prefix].Parent < Prefix);
-      Prefix = Nodes[Prefix].Parent;
+  if (DumpCumulative) {
+    Str << "Cumulative times:\n";
+    DumpMapType CumulativeMap;
+    for (TTindex i = 1; i < Nodes.size(); ++i) {
+      TTindex Prefix = i;
+      IceString Suffix = "";
+      while (Prefix) {
+        if (Suffix.empty())
+          Suffix = IDs[Nodes[Prefix].Interior];
+        else
+          Suffix = IDs[Nodes[Prefix].Interior] + "." + Suffix;
+        assert(Nodes[Prefix].Parent < Prefix);
+        Prefix = Nodes[Prefix].Parent;
+      }
+      CumulativeMap.insert(std::make_pair(Nodes[i].Time, Suffix));
     }
-    CumulativeMap.insert(std::make_pair(Nodes[i].Time, Suffix));
+    dumpHelper(Str, CumulativeMap, TotalTime);
   }
-  dumpHelper(Str, CumulativeMap, TotalTime);
-  Str << "Flat function times:\n";
+  Str << "Flat times:\n";
   DumpMapType FlatMap;
   for (TimerIdT i = 0; i < LeafTimes.size(); ++i) {
     FlatMap.insert(std::make_pair(LeafTimes[i], IDs[i]));
   }
   dumpHelper(Str, FlatMap, TotalTime);
   Str << "Number of timer updates: " << StateChangeCount << "\n";
 }
 
 double TimerStack::timestamp() {
   // TODO: Implement in terms of std::chrono for C++11.
   return llvm::TimeRecord::getCurrentTime(false).getWallTime();
 }
 
 } // end of namespace Ice