//===-- 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.
-//
+//
//===----------------------------------------------------------------------===//
//
// Interval Timing implementation.
//
//===----------------------------------------------------------------------===//
-#include "Support/Timer.h"
-#include "Support/CommandLine.h"
-#include "Config/sys/resource.h"
-#include "Config/sys/time.h"
-#include "Config/unistd.h"
-#include "Config/malloc.h"
-#include <iostream>
+#include "llvm/Support/Timer.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Streams.h"
+#include "llvm/System/Process.h"
#include <algorithm>
-#include <functional>
#include <fstream>
+#include <functional>
#include <map>
using namespace llvm;
-// GetLibSupportInfoOutputFile - Return a file stream to print our output on...
+// GetLibSupportInfoOutputFile - Return a file stream to print our output on.
namespace llvm { extern std::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;
}
namespace {
-#ifdef HAVE_MALLINFO
cl::opt<bool>
TrackSpace("track-memory", cl::desc("Enable -time-passes memory "
"tracking (this may be slow)"),
cl::Hidden);
-#endif
cl::opt<std::string, true>
InfoOutputFilename("info-output-file", cl::value_desc("filename"),
}
}
-static long getMemUsage() {
-#ifdef HAVE_MALLINFO
- if (TrackSpace) {
- struct mallinfo MI = mallinfo();
- return MI.uordblks/*+MI.hblkhd*/;
- }
-#endif
+static inline size_t getMemUsage() {
+ if (TrackSpace)
+ return sys::Process::GetMallocUsage();
return 0;
}
struct TimeRecord {
double Elapsed, UserTime, SystemTime;
- long MemUsed;
+ ssize_t MemUsed;
};
static TimeRecord getTimeRecord(bool Start) {
- struct rusage RU;
- struct timeval T;
- long MemUsed = 0;
+ TimeRecord Result;
+
+ sys::TimeValue now(0,0);
+ sys::TimeValue user(0,0);
+ sys::TimeValue sys(0,0);
+
+ ssize_t MemUsed = 0;
if (Start) {
MemUsed = getMemUsage();
- if (getrusage(RUSAGE_SELF, &RU))
- perror("getrusage call failed: -time-passes info incorrect!");
- }
- gettimeofday(&T, 0);
-
- if (!Start) {
- if (getrusage(RUSAGE_SELF, &RU))
- perror("getrusage call failed: -time-passes info incorrect!");
+ sys::Process::GetTimeUsage(now,user,sys);
+ } else {
+ sys::Process::GetTimeUsage(now,user,sys);
MemUsed = getMemUsage();
}
- TimeRecord Result;
- Result.Elapsed = T.tv_sec + T.tv_usec/1000000.0;
- Result.UserTime = RU.ru_utime.tv_sec + RU.ru_utime.tv_usec/1000000.0;
- Result.SystemTime = RU.ru_stime.tv_sec + RU.ru_stime.tv_usec/1000000.0;
- Result.MemUsed = MemUsed;
+ 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;
return Result;
}
-static std::vector<Timer*> ActiveTimers;
+static ManagedStatic<std::vector<Timer*> > ActiveTimers;
void Timer::startTimer() {
Started = true;
SystemTime -= TR.SystemTime;
MemUsed -= TR.MemUsed;
PeakMemBase = TR.MemUsed;
- ActiveTimers.push_back(this);
+ ActiveTimers->push_back(this);
}
void Timer::stopTimer() {
SystemTime += TR.SystemTime;
MemUsed += TR.MemUsed;
- if (ActiveTimers.back() == this) {
- ActiveTimers.pop_back();
+ 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);
}
}
/// currently active timers, which will be printed when the timer group prints
///
void Timer::addPeakMemoryMeasurement() {
- long MemUsed = getMemUsage();
+ size_t MemUsed = getMemUsage();
- for (std::vector<Timer*>::iterator I = ActiveTimers.begin(),
- E = ActiveTimers.end(); I != E; ++I)
+ for (std::vector<Timer*>::iterator I = ActiveTimers->begin(),
+ E = ActiveTimers->end(); I != E; ++I)
(*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase);
}
// NamedRegionTimer Implementation
//===----------------------------------------------------------------------===//
-static Timer &getNamedRegionTimer(const std::string &Name) {
- static std::map<std::string, Timer> NamedTimers;
+static ManagedStatic<std::map<std::string, Timer> > NamedTimers;
- std::map<std::string, Timer>::iterator I = NamedTimers.lower_bound(Name);
- if (I != NamedTimers.end() && I->first == Name)
+static Timer &getNamedRegionTimer(const std::string &Name) {
+ std::map<std::string, Timer>::iterator I = NamedTimers->lower_bound(Name);
+ if (I != NamedTimers->end() && I->first == Name)
return I->second;
- return NamedTimers.insert(I, std::make_pair(Name, Timer(Name)))->second;
+ return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;
}
NamedRegionTimer::NamedRegionTimer(const std::string &Name)
if (Total.getProcessTime())
printVal(getProcessTime(), Total.getProcessTime(), OS);
printVal(Elapsed, Total.Elapsed, OS);
-
+
OS << " ";
if (Total.MemUsed) {
llvm::GetLibSupportInfoOutputFile() {
std::string &LibSupportInfoOutputFilename = getLibSupportInfoOutputFilename();
if (LibSupportInfoOutputFilename.empty())
- return &std::cerr;
+ return cerr.stream();
if (LibSupportInfoOutputFilename == "-")
- return &std::cout;
+ return cout.stream();
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";
+ cerr << "Error opening info-output-file '"
+ << LibSupportInfoOutputFilename << " for appending!\n";
delete Result;
- return &std::cerr;
+ return cerr.stream();
}
return Result;
}
{ // 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: ";
+ << "===\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: ";
- printAlignedFP(Total.getProcessTime(), 4, 5, *OutStream);
- *OutStream << " seconds (";
- printAlignedFP(Total.getWallTime(), 4, 5, *OutStream);
- *OutStream << " wall clock)\n\n";
+ printAlignedFP(Total.getProcessTime(), 4, 5, *OutStream);
+ *OutStream << " seconds (";
+ printAlignedFP(Total.getWallTime(), 4, 5, *OutStream);
+ *OutStream << " wall clock)\n";
+ }
+ *OutStream << "\n";
if (Total.UserTime)
*OutStream << " ---User Time---";
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
}
TimersToPrint.clear();
- if (OutStream != &std::cerr && OutStream != &std::cout)
+ if (OutStream != cerr.stream() && OutStream != cout.stream())
delete OutStream; // Close the file...
}
projects / oota-llvm.git / blobdiff