Timer.cpp revision 199481 
1//===-- Timer.cpp - Interval Timing Support -------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// Interval Timing implementation.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Support/Timer.h"
15#include "llvm/Support/CommandLine.h"
16#include "llvm/Support/ManagedStatic.h"
17#include "llvm/Support/raw_ostream.h"
18#include "llvm/Support/Format.h"
19#include "llvm/System/Process.h"
20#include <algorithm>
21#include <functional>
22#include <map>
23using namespace llvm;
24
25// GetLibSupportInfoOutputFile - Return a file stream to print our output on.
26namespace llvm { extern raw_ostream *GetLibSupportInfoOutputFile(); }
27
28// getLibSupportInfoOutputFilename - This ugly hack is brought to you courtesy
29// of constructor/destructor ordering being unspecified by C++.  Basically the
30// problem is that a Statistic object gets destroyed, which ends up calling
31// 'GetLibSupportInfoOutputFile()' (below), which calls this function.
32// LibSupportInfoOutputFilename used to be a global variable, but sometimes it
33// would get destroyed before the Statistic, causing havoc to ensue.  We "fix"
34// this by creating the string the first time it is needed and never destroying
35// it.
36static ManagedStatic<std::string> LibSupportInfoOutputFilename;
37static std::string &getLibSupportInfoOutputFilename() {
38  return *LibSupportInfoOutputFilename;
39}
40
41static ManagedStatic<sys::SmartMutex<true> > TimerLock;
42
43namespace {
44  static cl::opt<bool>
45  TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
46                                      "tracking (this may be slow)"),
47             cl::Hidden);
48
49  static cl::opt<std::string, true>
50  InfoOutputFilename("info-output-file", cl::value_desc("filename"),
51                     cl::desc("File to append -stats and -timer output to"),
52                   cl::Hidden, cl::location(getLibSupportInfoOutputFilename()));
53}
54
55static TimerGroup *DefaultTimerGroup = 0;
56static TimerGroup *getDefaultTimerGroup() {
57  TimerGroup* tmp = DefaultTimerGroup;
58  sys::MemoryFence();
59  if (!tmp) {
60    llvm_acquire_global_lock();
61    tmp = DefaultTimerGroup;
62    if (!tmp) {
63      tmp = new TimerGroup("Miscellaneous Ungrouped Timers");
64      sys::MemoryFence();
65      DefaultTimerGroup = tmp;
66    }
67    llvm_release_global_lock();
68  }
69
70  return tmp;
71}
72
73Timer::Timer(const std::string &N)
74  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), PeakMem(0), Name(N),
75    Started(false), TG(getDefaultTimerGroup()) {
76  TG->addTimer();
77}
78
79Timer::Timer(const std::string &N, TimerGroup &tg)
80  : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), PeakMem(0), Name(N),
81    Started(false), TG(&tg) {
82  TG->addTimer();
83}
84
85Timer::Timer(const Timer &T) {
86  TG = T.TG;
87  if (TG) TG->addTimer();
88  operator=(T);
89}
90
91
92// Copy ctor, initialize with no TG member.
93Timer::Timer(bool, const Timer &T) {
94  TG = T.TG;     // Avoid assertion in operator=
95  operator=(T);  // Copy contents
96  TG = 0;
97}
98
99
100Timer::~Timer() {
101  if (TG) {
102    if (Started) {
103      Started = false;
104      TG->addTimerToPrint(*this);
105    }
106    TG->removeTimer();
107  }
108}
109
110static inline size_t getMemUsage() {
111  if (TrackSpace)
112    return sys::Process::GetMallocUsage();
113  return 0;
114}
115
116struct TimeRecord {
117  double Elapsed, UserTime, SystemTime;
118  ssize_t MemUsed;
119};
120
121static TimeRecord getTimeRecord(bool Start) {
122  TimeRecord Result;
123
124  sys::TimeValue now(0,0);
125  sys::TimeValue user(0,0);
126  sys::TimeValue sys(0,0);
127
128  ssize_t MemUsed = 0;
129  if (Start) {
130    MemUsed = getMemUsage();
131    sys::Process::GetTimeUsage(now,user,sys);
132  } else {
133    sys::Process::GetTimeUsage(now,user,sys);
134    MemUsed = getMemUsage();
135  }
136
137  Result.Elapsed  = now.seconds()  + now.microseconds()  / 1000000.0;
138  Result.UserTime = user.seconds() + user.microseconds() / 1000000.0;
139  Result.SystemTime  = sys.seconds()  + sys.microseconds()  / 1000000.0;
140  Result.MemUsed  = MemUsed;
141
142  return Result;
143}
144
145static ManagedStatic<std::vector<Timer*> > ActiveTimers;
146
147void Timer::startTimer() {
148  sys::SmartScopedLock<true> L(*TimerLock);
149  Started = true;
150  ActiveTimers->push_back(this);
151  TimeRecord TR = getTimeRecord(true);
152  Elapsed    -= TR.Elapsed;
153  UserTime   -= TR.UserTime;
154  SystemTime -= TR.SystemTime;
155  MemUsed    -= TR.MemUsed;
156  PeakMemBase = TR.MemUsed;
157}
158
159void Timer::stopTimer() {
160  sys::SmartScopedLock<true> L(*TimerLock);
161  TimeRecord TR = getTimeRecord(false);
162  Elapsed    += TR.Elapsed;
163  UserTime   += TR.UserTime;
164  SystemTime += TR.SystemTime;
165  MemUsed    += TR.MemUsed;
166
167  if (ActiveTimers->back() == this) {
168    ActiveTimers->pop_back();
169  } else {
170    std::vector<Timer*>::iterator I =
171      std::find(ActiveTimers->begin(), ActiveTimers->end(), this);
172    assert(I != ActiveTimers->end() && "stop but no startTimer?");
173    ActiveTimers->erase(I);
174  }
175}
176
177void Timer::sum(const Timer &T) {
178  Elapsed    += T.Elapsed;
179  UserTime   += T.UserTime;
180  SystemTime += T.SystemTime;
181  MemUsed    += T.MemUsed;
182  PeakMem    += T.PeakMem;
183}
184
185/// addPeakMemoryMeasurement - This method should be called whenever memory
186/// usage needs to be checked.  It adds a peak memory measurement to the
187/// currently active timers, which will be printed when the timer group prints
188///
189void Timer::addPeakMemoryMeasurement() {
190  sys::SmartScopedLock<true> L(*TimerLock);
191  size_t MemUsed = getMemUsage();
192
193  for (std::vector<Timer*>::iterator I = ActiveTimers->begin(),
194         E = ActiveTimers->end(); I != E; ++I)
195    (*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase);
196}
197
198//===----------------------------------------------------------------------===//
199//   NamedRegionTimer Implementation
200//===----------------------------------------------------------------------===//
201
202namespace {
203
204typedef std::map<std::string, Timer> Name2Timer;
205typedef std::map<std::string, std::pair<TimerGroup, Name2Timer> > Name2Pair;
206
207}
208
209static ManagedStatic<Name2Timer> NamedTimers;
210
211static ManagedStatic<Name2Pair> NamedGroupedTimers;
212
213static Timer &getNamedRegionTimer(const std::string &Name) {
214  sys::SmartScopedLock<true> L(*TimerLock);
215  Name2Timer::iterator I = NamedTimers->find(Name);
216  if (I != NamedTimers->end())
217    return I->second;
218
219  return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;
220}
221
222static Timer &getNamedRegionTimer(const std::string &Name,
223                                  const std::string &GroupName) {
224  sys::SmartScopedLock<true> L(*TimerLock);
225
226  Name2Pair::iterator I = NamedGroupedTimers->find(GroupName);
227  if (I == NamedGroupedTimers->end()) {
228    TimerGroup TG(GroupName);
229    std::pair<TimerGroup, Name2Timer> Pair(TG, Name2Timer());
230    I = NamedGroupedTimers->insert(I, std::make_pair(GroupName, Pair));
231  }
232
233  Name2Timer::iterator J = I->second.second.find(Name);
234  if (J == I->second.second.end())
235    J = I->second.second.insert(J,
236                                std::make_pair(Name,
237                                               Timer(Name,
238                                                     I->second.first)));
239
240  return J->second;
241}
242
243NamedRegionTimer::NamedRegionTimer(const std::string &Name)
244  : TimeRegion(getNamedRegionTimer(Name)) {}
245
246NamedRegionTimer::NamedRegionTimer(const std::string &Name,
247                                   const std::string &GroupName)
248  : TimeRegion(getNamedRegionTimer(Name, GroupName)) {}
249
250//===----------------------------------------------------------------------===//
251//   TimerGroup Implementation
252//===----------------------------------------------------------------------===//
253
254
255static void printVal(double Val, double Total, raw_ostream &OS) {
256  if (Total < 1e-7)   // Avoid dividing by zero...
257    OS << "        -----     ";
258  else {
259    OS << "  " << format("%7.4f", Val) << " (";
260    OS << format("%5.1f", Val*100/Total) << "%)";
261  }
262}
263
264void Timer::print(const Timer &Total, raw_ostream &OS) {
265  sys::SmartScopedLock<true> L(*TimerLock);
266  if (Total.UserTime)
267    printVal(UserTime, Total.UserTime, OS);
268  if (Total.SystemTime)
269    printVal(SystemTime, Total.SystemTime, OS);
270  if (Total.getProcessTime())
271    printVal(getProcessTime(), Total.getProcessTime(), OS);
272  printVal(Elapsed, Total.Elapsed, OS);
273
274  OS << "  ";
275
276  if (Total.MemUsed) {
277    OS << format("%9lld", (long long)MemUsed) << "  ";
278  }
279  if (Total.PeakMem) {
280    if (PeakMem) {
281      OS << format("%9lld", (long long)PeakMem) << "  ";
282    } else
283      OS << "           ";
284  }
285  OS << Name << "\n";
286
287  Started = false;  // Once printed, don't print again
288}
289
290// GetLibSupportInfoOutputFile - Return a file stream to print our output on...
291raw_ostream *
292llvm::GetLibSupportInfoOutputFile() {
293  std::string &LibSupportInfoOutputFilename = getLibSupportInfoOutputFilename();
294  if (LibSupportInfoOutputFilename.empty())
295    return &errs();
296  if (LibSupportInfoOutputFilename == "-")
297    return &outs();
298
299
300  std::string Error;
301  raw_ostream *Result = new raw_fd_ostream(LibSupportInfoOutputFilename.c_str(),
302                                           Error, raw_fd_ostream::F_Append);
303  if (Error.empty())
304    return Result;
305
306  errs() << "Error opening info-output-file '"
307         << LibSupportInfoOutputFilename << " for appending!\n";
308  delete Result;
309  return &errs();
310}
311
312
313void TimerGroup::removeTimer() {
314  sys::SmartScopedLock<true> L(*TimerLock);
315  if (--NumTimers == 0 && !TimersToPrint.empty()) { // Print timing report...
316    // Sort the timers in descending order by amount of time taken...
317    std::sort(TimersToPrint.begin(), TimersToPrint.end(),
318              std::greater<Timer>());
319
320    // Figure out how many spaces to indent TimerGroup name...
321    unsigned Padding = (80-Name.length())/2;
322    if (Padding > 80) Padding = 0;         // Don't allow "negative" numbers
323
324    raw_ostream *OutStream = GetLibSupportInfoOutputFile();
325
326    ++NumTimers;
327    {  // Scope to contain Total timer... don't allow total timer to drop us to
328       // zero timers...
329      Timer Total("TOTAL");
330
331      for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
332        Total.sum(TimersToPrint[i]);
333
334      // Print out timing header...
335      *OutStream << "===" << std::string(73, '-') << "===\n"
336                 << std::string(Padding, ' ') << Name << "\n"
337                 << "===" << std::string(73, '-')
338                 << "===\n";
339
340      // If this is not an collection of ungrouped times, print the total time.
341      // Ungrouped timers don't really make sense to add up.  We still print the
342      // TOTAL line to make the percentages make sense.
343      if (this != DefaultTimerGroup) {
344        *OutStream << "  Total Execution Time: ";
345
346        *OutStream << format("%5.4f", Total.getProcessTime()) << " seconds (";
347        *OutStream << format("%5.4f", Total.getWallTime()) << " wall clock)\n";
348      }
349      *OutStream << "\n";
350
351      if (Total.UserTime)
352        *OutStream << "   ---User Time---";
353      if (Total.SystemTime)
354        *OutStream << "   --System Time--";
355      if (Total.getProcessTime())
356        *OutStream << "   --User+System--";
357      *OutStream << "   ---Wall Time---";
358      if (Total.getMemUsed())
359        *OutStream << "  ---Mem---";
360      if (Total.getPeakMem())
361        *OutStream << "  -PeakMem-";
362      *OutStream << "  --- Name ---\n";
363
364      // Loop through all of the timing data, printing it out...
365      for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
366        TimersToPrint[i].print(Total, *OutStream);
367
368      Total.print(Total, *OutStream);
369      *OutStream << '\n';
370      OutStream->flush();
371    }
372    --NumTimers;
373
374    TimersToPrint.clear();
375
376    if (OutStream != &errs() && OutStream != &outs())
377      delete OutStream;   // Close the file...
378  }
379}
380
381void TimerGroup::addTimer() {
382  sys::SmartScopedLock<true> L(*TimerLock);
383  ++NumTimers;
384}
385
386void TimerGroup::addTimerToPrint(const Timer &T) {
387  sys::SmartScopedLock<true> L(*TimerLock);
388  TimersToPrint.push_back(Timer(true, T));
389}
390
391