Subzero: Disable stats and timers under the MINIMAL build.

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 {
 
 TimerStack::TimerStack(const IceString &Name)
     : Name(Name), FirstTimestamp(timestamp()), LastTimestamp(FirstTimestamp),
       StateChangeCount(0), StackTop(0) {
+  if (!ALLOW_DUMP)
+    return;
   Nodes.resize(1); // Reserve Nodes[0] for the root node.
   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.
 TimerIdT TimerStack::getTimerID(const IceString &Name) {
+  if (!ALLOW_DUMP)
+    return 0;
   if (IDsIndex.find(Name) == IDsIndex.end()) {
     IDsIndex[Name] = IDs.size();
     IDs.push_back(Name);
   }
   return IDsIndex[Name];
 }
 
 // Pushes a new marker onto the timer stack.
 void TimerStack::push(TimerIdT ID) {

[Karl, 2014/12/08 21:08:01]

Suggest adding quick cutoff here as well. That way, we don't have to count on
the callers removing this.

[Jim Stichnoth, 2014/12/08 21:33:57]

Done.

   const bool UpdateCounts = false;
   update(UpdateCounts);
   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;
     Nodes.resize(Size + 1);
     Nodes[Size].Parent = StackTop;
     Nodes[Size].Interior = ID;
   }
   StackTop = Nodes[StackTop].Children[ID];
 }
 
 // Pop the top marker from the timer stack.  Validates via assert()
 // that the expected marker is popped.
 void TimerStack::pop(TimerIdT ID) {

[Karl, 2014/12/08 21:08:01]

Same here.

[Jim Stichnoth, 2014/12/08 21:33:57]

Done.

   const bool UpdateCounts = true;
   update(UpdateCounts);
   assert(StackTop);
   assert(Nodes[StackTop].Parent < StackTop);
   // Verify that the expected ID is being popped.
   assert(Nodes[StackTop].Interior == ID);
   (void)ID;
   // Verify that the parent's child points to the current stack top.
   assert(Nodes[Nodes[StackTop].Parent].Children[ID] == StackTop);
   StackTop = Nodes[StackTop].Parent;
 }
 
 // At a state change (e.g. push or pop), updates the flat and
 // cumulative timings for everything on the timer stack.
 void TimerStack::update(bool UpdateCounts) {

[Karl, 2014/12/08 21:08:01]

Same here.

[Jim Stichnoth, 2014/12/08 21:33:57]

Done.

   ++StateChangeCount;
   // Whenever the stack is about to change, we grab the time delta
   // since the last change and add it to all active cumulative
   // elements and to the flat element for the top of the stack.
   double Current = timestamp();
   double Delta = Current - LastTimestamp;
   if (StackTop) {
     TimerIdT Leaf = Nodes[StackTop].Interior;
     if (Leaf >= LeafTimes.size()) {
       LeafTimes.resize(Leaf + 1);
@@ skipping 13 matching lines @@
     assert(Next < Prefix);
     Prefix = Next;
   }
   // Capture the next timestamp *after* the updates are finished.
   // This minimizes how much the timer can perturb the reported
   // timing.  The numbers may not sum to 100%, and the missing amount
   // is indicative of the overhead of timing.
   LastTimestamp = timestamp();
 }
 
 void TimerStack::reset() {

[Karl, 2014/12/08 21:08:01]

Same here.

[Jim Stichnoth, 2014/12/08 21:33:57]

Done.

   StateChangeCount = 0;
   FirstTimestamp = LastTimestamp = timestamp();
   LeafTimes.assign(LeafTimes.size(), 0);
   LeafCounts.assign(LeafCounts.size(), 0);
   for (TimerTreeNode &Node : Nodes) {
     Node.Time = 0;
     Node.UpdateCount = 0;
   }
 }
 
@@ skipping 83 matching lines @@
   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