X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FTimer.cpp;h=96f440a4ed4189bbb15aa14681c20c43170fc917;hb=a782e75d487006cafffdc256b3c623307fee4dcf;hp=38a8b449f34edf3b38e0e20ed26d4da978fce13b;hpb=7cf9ad36982b18a548fd45db0c001296533c44da;p=oota-llvm.git

diff --git a/lib/Support/Timer.cpp b/lib/Support/Timer.cpp
index 38a8b449f34..96f440a4ed4 100644
--- a/lib/Support/Timer.cpp
+++ b/lib/Support/Timer.cpp
@@ -1,10 +1,10 @@
 //===-- Timer.cpp - Interval Timing Support -------------------------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
 //===----------------------------------------------------------------------===//
 //
 // Interval Timing implementation.
@@ -13,335 +13,304 @@
 
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/Format.h"
+#include "llvm/System/Mutex.h"
 #include "llvm/System/Process.h"
-#include <algorithm>
-#include <fstream>
-#include <functional>
-#include <iostream>
+#include "llvm/ADT/StringMap.h"
 #include <map>
-
 using namespace llvm;
 
 // GetLibSupportInfoOutputFile - Return a file stream to print our output on.
-namespace llvm { extern std::ostream *GetLibSupportInfoOutputFile(); }
+namespace llvm { extern raw_ostream *GetLibSupportInfoOutputFile(); }
 
 // getLibSupportInfoOutputFilename - This ugly hack is brought to you courtesy
 // of constructor/destructor ordering being unspecified by C++.  Basically the
-// problem is that a Statistic<> object gets destroyed, which ends up calling
+// problem is that a Statistic object gets destroyed, which ends up calling
 // 'GetLibSupportInfoOutputFile()' (below), which calls this function.
 // LibSupportInfoOutputFilename used to be a global variable, but sometimes it
 // would get destroyed before the Statistic, causing havoc to ensue.  We "fix"
 // this by creating the string the first time it is needed and never destroying
 // it.
+static ManagedStatic<std::string> LibSupportInfoOutputFilename;
 static std::string &getLibSupportInfoOutputFilename() {
-  static std::string *LibSupportInfoOutputFilename = new std::string();
   return *LibSupportInfoOutputFilename;
 }
 
+static ManagedStatic<sys::SmartMutex<true> > TimerLock;
+
 namespace {
-  cl::opt<bool>
+  static cl::opt<bool>
   TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
                                       "tracking (this may be slow)"),
              cl::Hidden);
 
-  cl::opt<std::string, true>
+  static cl::opt<std::string, true>
   InfoOutputFilename("info-output-file", cl::value_desc("filename"),
                      cl::desc("File to append -stats and -timer output to"),
                    cl::Hidden, cl::location(getLibSupportInfoOutputFilename()));
 }
 
-static TimerGroup *DefaultTimerGroup = 0;
-static TimerGroup *getDefaultTimerGroup() {
-  if (DefaultTimerGroup) return DefaultTimerGroup;
-  return DefaultTimerGroup = new TimerGroup("Miscellaneous Ungrouped Timers");
+// GetLibSupportInfoOutputFile - Return a file stream to print our output on.
+raw_ostream *llvm::GetLibSupportInfoOutputFile() {
+  std::string &LibSupportInfoOutputFilename = getLibSupportInfoOutputFilename();
+  if (LibSupportInfoOutputFilename.empty())
+    return &errs();
+  if (LibSupportInfoOutputFilename == "-")
+    return &outs();
+  
+  std::string Error;
+  raw_ostream *Result = new raw_fd_ostream(LibSupportInfoOutputFilename.c_str(),
+                                           Error, raw_fd_ostream::F_Append);
+  if (Error.empty())
+    return Result;
+  
+  errs() << "Error opening info-output-file '"
+    << LibSupportInfoOutputFilename << " for appending!\n";
+  delete Result;
+  return &errs();
 }
 
-Timer::Timer(const std::string &N)
-  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), PeakMem(0), Name(N),
-    Started(false), TG(getDefaultTimerGroup()) {
-  TG->addTimer();
-}
 
-Timer::Timer(const std::string &N, TimerGroup &tg)
-  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), PeakMem(0), Name(N),
-    Started(false), TG(&tg) {
-  TG->addTimer();
-}
+static TimerGroup *DefaultTimerGroup = 0;
+static TimerGroup *getDefaultTimerGroup() {
+  TimerGroup *tmp = DefaultTimerGroup;
+  sys::MemoryFence();
+  if (tmp) return tmp;
+  
+  llvm_acquire_global_lock();
+  tmp = DefaultTimerGroup;
+  if (!tmp) {
+    tmp = new TimerGroup("Miscellaneous Ungrouped Timers");
+    sys::MemoryFence();
+    DefaultTimerGroup = tmp;
+  }
+  llvm_release_global_lock();
 
-Timer::Timer(const Timer &T) {
-  TG = T.TG;
-  if (TG) TG->addTimer();
-  operator=(T);
+  return tmp;
 }
 
+//===----------------------------------------------------------------------===//
+// Timer Implementation
+//===----------------------------------------------------------------------===//
 
-// Copy ctor, initialize with no TG member.
-Timer::Timer(bool, const Timer &T) {
-  TG = T.TG;     // Avoid assertion in operator=
-  operator=(T);  // Copy contents
-  TG = 0;
+void Timer::init(const std::string &N) {
+  assert(TG == 0 && "Timer already initialized");
+  Name = N;
+  Started = false;
+  TG = getDefaultTimerGroup();
+  TG->addTimer();
 }
 
+void Timer::init(const std::string &N, TimerGroup &tg) {
+  assert(TG == 0 && "Timer already initialized");
+  Name = N;
+  Started = false;
+  TG = &tg;
+  TG->addTimer();
+}
 
 Timer::~Timer() {
-  if (TG) {
-    if (Started) {
-      Started = false;
-      TG->addTimerToPrint(*this);
-    }
-    TG->removeTimer();
+  if (!TG) return;  // Never initialized.
+  
+  if (Started) {
+    Started = false;
+    TG->addTimerToPrint(Time, Name);
   }
+  TG->removeTimer();
 }
 
-static inline long getMemUsage() {
+static inline size_t getMemUsage() {
   if (TrackSpace)
-    return (long)sys::Process::GetMallocUsage();
+    return sys::Process::GetMallocUsage();
   return 0;
 }
 
-struct TimeRecord {
-  double Elapsed, UserTime, SystemTime;
-  long MemUsed;
-};
-
-static TimeRecord getTimeRecord(bool Start) {
+TimeRecord TimeRecord::getCurrentTime(bool Start) {
   TimeRecord Result;
 
   sys::TimeValue now(0,0);
   sys::TimeValue user(0,0);
   sys::TimeValue sys(0,0);
 
-  long MemUsed = 0;
+  ssize_t MemUsed = 0;
   if (Start) {
-    sys::Process::GetTimeUsage(now,user,sys);
     MemUsed = getMemUsage();
+    sys::Process::GetTimeUsage(now, user, sys);
   } else {
+    sys::Process::GetTimeUsage(now, user, sys);
     MemUsed = getMemUsage();
-    sys::Process::GetTimeUsage(now,user,sys);
   }
 
-  Result.Elapsed  = now.seconds()  + now.microseconds()  / 1000000.0;
-  Result.UserTime = user.seconds() + user.microseconds() / 1000000.0;
-  Result.SystemTime  = sys.seconds()  + sys.microseconds()  / 1000000.0;
-  Result.MemUsed  = MemUsed;
-
+  Result.WallTime   =  now.seconds() +  now.microseconds() / 1000000.0;
+  Result.UserTime   = user.seconds() + user.microseconds() / 1000000.0;
+  Result.SystemTime =  sys.seconds() +  sys.microseconds() / 1000000.0;
+  Result.MemUsed = MemUsed;
   return Result;
 }
 
-static std::vector<Timer*> ActiveTimers;
+static ManagedStatic<std::vector<Timer*> > ActiveTimers;
 
 void Timer::startTimer() {
   Started = true;
-  TimeRecord TR = getTimeRecord(true);
-  Elapsed    -= TR.Elapsed;
-  UserTime   -= TR.UserTime;
-  SystemTime -= TR.SystemTime;
-  MemUsed    -= TR.MemUsed;
-  PeakMemBase = TR.MemUsed;
-  ActiveTimers.push_back(this);
+  ActiveTimers->push_back(this);
+  Time -= TimeRecord::getCurrentTime(true);
 }
 
 void Timer::stopTimer() {
-  TimeRecord TR = getTimeRecord(false);
-  Elapsed    += TR.Elapsed;
-  UserTime   += TR.UserTime;
-  SystemTime += TR.SystemTime;
-  MemUsed    += TR.MemUsed;
-
-  if (ActiveTimers.back() == this) {
-    ActiveTimers.pop_back();
+  Time += TimeRecord::getCurrentTime(false);
+
+  if (ActiveTimers->back() == this) {
+    ActiveTimers->pop_back();
   } else {
     std::vector<Timer*>::iterator I =
-      std::find(ActiveTimers.begin(), ActiveTimers.end(), this);
-    assert(I != ActiveTimers.end() && "stop but no startTimer?");
-    ActiveTimers.erase(I);
+      std::find(ActiveTimers->begin(), ActiveTimers->end(), this);
+    assert(I != ActiveTimers->end() && "stop but no startTimer?");
+    ActiveTimers->erase(I);
   }
 }
 
-void Timer::sum(const Timer &T) {
-  Elapsed    += T.Elapsed;
-  UserTime   += T.UserTime;
-  SystemTime += T.SystemTime;
-  MemUsed    += T.MemUsed;
-  PeakMem    += T.PeakMem;
+static void printVal(double Val, double Total, raw_ostream &OS) {
+  if (Total < 1e-7)   // Avoid dividing by zero.
+    OS << "        -----     ";
+  else {
+    OS << "  " << format("%7.4f", Val) << " (";
+    OS << format("%5.1f", Val*100/Total) << "%)";
+  }
 }
 
-/// addPeakMemoryMeasurement - This method should be called whenever memory
-/// usage needs to be checked.  It adds a peak memory measurement to the
-/// currently active timers, which will be printed when the timer group prints
-///
-void Timer::addPeakMemoryMeasurement() {
-  long MemUsed = getMemUsage();
-
-  for (std::vector<Timer*>::iterator I = ActiveTimers.begin(),
-         E = ActiveTimers.end(); I != E; ++I)
-    (*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase);
+void TimeRecord::print(const TimeRecord &Total, raw_ostream &OS) const {
+  if (Total.getUserTime())
+    printVal(getUserTime(), Total.getUserTime(), OS);
+  if (Total.getSystemTime())
+    printVal(getSystemTime(), Total.getSystemTime(), OS);
+  if (Total.getProcessTime())
+    printVal(getProcessTime(), Total.getProcessTime(), OS);
+  printVal(getWallTime(), Total.getWallTime(), OS);
+  
+  OS << "  ";
+  
+  if (Total.getMemUsed())
+    OS << format("%9lld", (long long)getMemUsed()) << "  ";
 }
 
+
 //===----------------------------------------------------------------------===//
 //   NamedRegionTimer Implementation
 //===----------------------------------------------------------------------===//
 
+typedef StringMap<Timer> Name2TimerMap;
+typedef StringMap<std::pair<TimerGroup, Name2TimerMap> > Name2PairMap;
+
+static ManagedStatic<Name2TimerMap> NamedTimers;
+static ManagedStatic<Name2PairMap> NamedGroupedTimers;
+
 static Timer &getNamedRegionTimer(const std::string &Name) {
-  static std::map<std::string, Timer> NamedTimers;
+  sys::SmartScopedLock<true> L(*TimerLock);
+  
+  Timer &T = (*NamedTimers)[Name];
+  if (!T.isInitialized())
+    T.init(Name);
+  return T;
+}
+
+static Timer &getNamedRegionTimer(const std::string &Name,
+                                  const std::string &GroupName) {
+  sys::SmartScopedLock<true> L(*TimerLock);
+
+  std::pair<TimerGroup, Name2TimerMap> &GroupEntry =
+    (*NamedGroupedTimers)[GroupName];
 
-  std::map<std::string, Timer>::iterator I = NamedTimers.lower_bound(Name);
-  if (I != NamedTimers.end() && I->first == Name)
-    return I->second;
+  if (GroupEntry.second.empty())
+    GroupEntry.first.setName(GroupName);
 
-  return NamedTimers.insert(I, std::make_pair(Name, Timer(Name)))->second;
+  Timer &T = GroupEntry.second[Name];
+  if (!T.isInitialized())
+    T.init(Name);
+  return T;
 }
 
 NamedRegionTimer::NamedRegionTimer(const std::string &Name)
   : TimeRegion(getNamedRegionTimer(Name)) {}
 
+NamedRegionTimer::NamedRegionTimer(const std::string &Name,
+                                   const std::string &GroupName)
+  : TimeRegion(getNamedRegionTimer(Name, GroupName)) {}
 
 //===----------------------------------------------------------------------===//
 //   TimerGroup Implementation
 //===----------------------------------------------------------------------===//
 
-// printAlignedFP - Simulate the printf "%A.Bf" format, where A is the
-// TotalWidth size, and B is the AfterDec size.
-//
-static void printAlignedFP(double Val, unsigned AfterDec, unsigned TotalWidth,
-                           std::ostream &OS) {
-  assert(TotalWidth >= AfterDec+1 && "Bad FP Format!");
-  OS.width(TotalWidth-AfterDec-1);
-  char OldFill = OS.fill();
-  OS.fill(' ');
-  OS << (int)Val;  // Integer part;
-  OS << ".";
-  OS.width(AfterDec);
-  OS.fill('0');
-  unsigned ResultFieldSize = 1;
-  while (AfterDec--) ResultFieldSize *= 10;
-  OS << (int)(Val*ResultFieldSize) % ResultFieldSize;
-  OS.fill(OldFill);
-}
-
-static void printVal(double Val, double Total, std::ostream &OS) {
-  if (Total < 1e-7)   // Avoid dividing by zero...
-    OS << "        -----     ";
-  else {
-    OS << "  ";
-    printAlignedFP(Val, 4, 7, OS);
-    OS << " (";
-    printAlignedFP(Val*100/Total, 1, 5, OS);
-    OS << "%)";
-  }
-}
-
-void Timer::print(const Timer &Total, std::ostream &OS) {
-  if (Total.UserTime)
-    printVal(UserTime, Total.UserTime, OS);
-  if (Total.SystemTime)
-    printVal(SystemTime, Total.SystemTime, OS);
-  if (Total.getProcessTime())
-    printVal(getProcessTime(), Total.getProcessTime(), OS);
-  printVal(Elapsed, Total.Elapsed, OS);
+void TimerGroup::removeTimer() {
+  sys::SmartScopedLock<true> L(*TimerLock);
+  if (--NumTimers != 0 || TimersToPrint.empty())
+    return; // Don't print timing report.
   
-  OS << "  ";
-
-  if (Total.MemUsed) {
-    OS.width(9);
-    OS << MemUsed << "  ";
-  }
-  if (Total.PeakMem) {
-    if (PeakMem) {
-      OS.width(9);
-      OS << PeakMem << "  ";
-    } else
-      OS << "           ";
+  // Sort the timers in descending order by amount of time taken.
+  std::sort(TimersToPrint.begin(), TimersToPrint.end());
+
+  // Figure out how many spaces to indent TimerGroup name.
+  unsigned Padding = (80-Name.length())/2;
+  if (Padding > 80) Padding = 0;         // Don't allow "negative" numbers
+
+  raw_ostream *OutStream = GetLibSupportInfoOutputFile();
+
+  TimeRecord Total;
+  for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
+    Total += TimersToPrint[i].first;
+
+  // Print out timing header.
+  *OutStream << "===" << std::string(73, '-') << "===\n";
+  OutStream->indent(Padding) << Name << '\n';
+  *OutStream << "===" << std::string(73, '-') << "===\n";
+
+  // If this is not an collection of ungrouped times, print the total time.
+  // Ungrouped timers don't really make sense to add up.  We still print the
+  // TOTAL line to make the percentages make sense.
+  if (this != DefaultTimerGroup) {
+    *OutStream << "  Total Execution Time: ";
+    *OutStream << format("%5.4f", Total.getProcessTime()) << " seconds (";
+    *OutStream << format("%5.4f", Total.getWallTime()) << " wall clock)\n";
   }
-  OS << Name << "\n";
-
-  Started = false;  // Once printed, don't print again
-}
+  *OutStream << "\n";
 
-// GetLibSupportInfoOutputFile - Return a file stream to print our output on...
-std::ostream *
-llvm::GetLibSupportInfoOutputFile() {
-  std::string &LibSupportInfoOutputFilename = getLibSupportInfoOutputFilename();
-  if (LibSupportInfoOutputFilename.empty())
-    return &std::cerr;
-  if (LibSupportInfoOutputFilename == "-")
-    return &std::cout;
-
-  std::ostream *Result = new std::ofstream(LibSupportInfoOutputFilename.c_str(),
-                                           std::ios::app);
-  if (!Result->good()) {
-    std::cerr << "Error opening info-output-file '"
-              << LibSupportInfoOutputFilename << " for appending!\n";
-    delete Result;
-    return &std::cerr;
+  if (Total.getUserTime())
+    *OutStream << "   ---User Time---";
+  if (Total.getSystemTime())
+    *OutStream << "   --System Time--";
+  if (Total.getProcessTime())
+    *OutStream << "   --User+System--";
+  *OutStream << "   ---Wall Time---";
+  if (Total.getMemUsed())
+    *OutStream << "  ---Mem---";
+  *OutStream << "  --- Name ---\n";
+
+  // Loop through all of the timing data, printing it out.
+  for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i) {
+    const std::pair<TimeRecord, std::string> &Entry = TimersToPrint[e-i-1];
+    Entry.first.print(Total, *OutStream);
+    *OutStream << Entry.second << '\n';
   }
-  return Result;
-}
 
+  Total.print(Total, *OutStream);
+  *OutStream << "Total\n\n";
+  OutStream->flush();
 
-void TimerGroup::removeTimer() {
-  if (--NumTimers == 0 && !TimersToPrint.empty()) { // Print timing report...
-    // Sort the timers in descending order by amount of time taken...
-    std::sort(TimersToPrint.begin(), TimersToPrint.end(),
-              std::greater<Timer>());
+  TimersToPrint.clear();
 
-    // Figure out how many spaces to indent TimerGroup name...
-    unsigned Padding = (80-Name.length())/2;
-    if (Padding > 80) Padding = 0;         // Don't allow "negative" numbers
-
-    std::ostream *OutStream = GetLibSupportInfoOutputFile();
+  if (OutStream != &errs() && OutStream != &outs())
+    delete OutStream;   // Close the file.
+}
 
-    ++NumTimers;
-    {  // Scope to contain Total timer... don't allow total timer to drop us to
-       // zero timers...
-      Timer Total("TOTAL");
-  
-      for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
-        Total.sum(TimersToPrint[i]);
-      
-      // Print out timing header...
-      *OutStream << "===" << std::string(73, '-') << "===\n"
-                 << std::string(Padding, ' ') << Name << "\n"
-                 << "===" << std::string(73, '-')
-                 << "===\n  Total Execution Time: ";
-
-      printAlignedFP(Total.getProcessTime(), 4, 5, *OutStream);
-      *OutStream << " seconds (";
-      printAlignedFP(Total.getWallTime(), 4, 5, *OutStream);
-      *OutStream << " wall clock)\n\n";
-
-      if (Total.UserTime)
-        *OutStream << "   ---User Time---";
-      if (Total.SystemTime)
-        *OutStream << "   --System Time--";
-      if (Total.getProcessTime())
-        *OutStream << "   --User+System--";
-      *OutStream << "   ---Wall Time---";
-      if (Total.getMemUsed())
-        *OutStream << "  ---Mem---";
-      if (Total.getPeakMem())
-        *OutStream << "  -PeakMem-";
-      *OutStream << "  --- Name ---\n";
-      
-      // Loop through all of the timing data, printing it out...
-      for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
-        TimersToPrint[i].print(Total, *OutStream);
-    
-      Total.print(Total, *OutStream);
-      *OutStream << std::endl;  // Flush output
-    }
-    --NumTimers;
-
-    TimersToPrint.clear();
-
-    if (OutStream != &std::cerr && OutStream != &std::cout)
-      delete OutStream;   // Close the file...
-  }
+void TimerGroup::addTimer() {
+  sys::SmartScopedLock<true> L(*TimerLock);
+  ++NumTimers;
+}
 
-  // Delete default timer group!
-  if (NumTimers == 0 && this == DefaultTimerGroup) {
-    delete DefaultTimerGroup;
-    DefaultTimerGroup = 0;
-  }
+void TimerGroup::addTimerToPrint(const TimeRecord &T, const std::string &Name) {
+  sys::SmartScopedLock<true> L(*TimerLock);
+  TimersToPrint.push_back(std::make_pair(T, Name));
 }