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)
-    : FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp),
+TimerStack::TimerStack(const IceString &Name)
+    : Name(Name), FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp),
       StateChangeCount(0), StackTop(0) {
   Nodes.resize(1); // Reserve Nodes[0] for the root node.
-  push(getTimerID(TopLevelName));
+  IDs.resize(TT__num);
+#define STR(s) #s
+#define X(tag)                                                                 \
+  IDs[TT_##tag] = STR(tag);                                                    \
+  IDsIndex[STR(tag)] = TT_##tag;
+  TIMERTREE_TABLE;
+#undef X
+#undef STR
 }
 
 // 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.
+// if needed.
 TimerIdT TimerStack::getTimerID(const IceString &Name) {
-  TimerIdT Size = IDs.size();
-  for (TimerIdT i = 0; i < Size; ++i) {
-    if (IDs[i] == Name)
-      return i;
+  if (IDsIndex.find(Name) == IDsIndex.end()) {
+    IDsIndex[Name] = IDs.size();
+    IDs.push_back(Name);
   }
-  IDs.push_back(Name);
-  return Size;
+  return IDsIndex[Name];
 }
 
 // Pushes a new marker onto the timer stack.
 void TimerStack::push(TimerIdT ID) {
   update();
   if (Nodes[StackTop].Children.size() <= ID)
     Nodes[StackTop].Children.resize(ID + 1);
   if (Nodes[StackTop].Children[ID] == 0) {
     TTindex Size = Nodes.size();
     Nodes[StackTop].Children[ID] = Size;
@@ skipping 53 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 << Name << " - 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 << Name << " - 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