X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FTimer.cpp;h=077995d9fb8993a21d4a07120d20e1c366b0854a;hb=3daae2701b76293c31c1cbdafc9782352321e1f0;hp=48b8f57c3fe5fe05fe27ca8d1351e629c3fa1b79;hpb=6cd11f6535600da5f286056748d4817e0f44b778;p=oota-llvm.git diff --git a/lib/Support/Timer.cpp b/lib/Support/Timer.cpp index 48b8f57c3fe..077995d9fb8 100644 --- a/lib/Support/Timer.cpp +++ b/lib/Support/Timer.cpp @@ -1,19 +1,54 @@ //===-- 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 -#include -#include -#include -#include -#include -#include +#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 +#include #include +#include +using namespace llvm; + +// 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 +// '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 LibSupportInfoOutputFilename; +static std::string &getLibSupportInfoOutputFilename() { + return *LibSupportInfoOutputFilename; +} + +namespace { + cl::opt + TrackSpace("track-memory", cl::desc("Enable -time-passes memory " + "tracking (this may be slow)"), + cl::Hidden); + + cl::opt + 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() { @@ -22,13 +57,13 @@ static TimerGroup *getDefaultTimerGroup() { } Timer::Timer(const std::string &N) - : Elapsed(0), UserTime(0), SystemTime(0), MaxRSS(0), Name(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), MaxRSS(0), Name(N), + : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), PeakMem(0), Name(N), Started(false), TG(&tg) { TG->addTimer(); } @@ -58,89 +93,191 @@ Timer::~Timer() { } } +static inline size_t getMemUsage() { + if (TrackSpace) + return sys::Process::GetMallocUsage(); + return 0; +} + struct TimeRecord { double Elapsed, UserTime, SystemTime; - unsigned long MaxRSS; + ssize_t MemUsed; }; -static TimeRecord getTimeRecord() { - struct rusage RU; - struct timeval T; - gettimeofday(&T, 0); - if (getrusage(RUSAGE_SELF, &RU)) { - perror("getrusage call failed: -time-passes info incorrect!"); - } - +static TimeRecord getTimeRecord(bool Start) { 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; -#ifndef __sparc__ - struct mallinfo MI = mallinfo(); - Result.MaxRSS = MI.uordblks; -#else - Result.MaxRSS = 0; -#endif + sys::TimeValue now(0,0); + sys::TimeValue user(0,0); + sys::TimeValue sys(0,0); + + ssize_t MemUsed = 0; + if (Start) { + MemUsed = getMemUsage(); + sys::Process::GetTimeUsage(now,user,sys); + } else { + sys::Process::GetTimeUsage(now,user,sys); + MemUsed = getMemUsage(); + } + + 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 ManagedStatic > ActiveTimers; + void Timer::startTimer() { Started = true; - TimeRecord TR = getTimeRecord(); + TimeRecord TR = getTimeRecord(true); Elapsed -= TR.Elapsed; UserTime -= TR.UserTime; SystemTime -= TR.SystemTime; - MaxRSS -= TR.MaxRSS; + MemUsed -= TR.MemUsed; + PeakMemBase = TR.MemUsed; + ActiveTimers->push_back(this); } void Timer::stopTimer() { - TimeRecord TR = getTimeRecord(); + TimeRecord TR = getTimeRecord(false); Elapsed += TR.Elapsed; UserTime += TR.UserTime; SystemTime += TR.SystemTime; - MaxRSS += TR.MaxRSS; - if ((signed long)MaxRSS < 0) - MaxRSS = 0; + MemUsed += TR.MemUsed; + + if (ActiveTimers->back() == this) { + ActiveTimers->pop_back(); + } else { + std::vector::iterator 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; - MaxRSS += T.MaxRSS; + MemUsed += T.MemUsed; + PeakMem += T.PeakMem; } +/// 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() { + size_t MemUsed = getMemUsage(); + + for (std::vector::iterator I = ActiveTimers->begin(), + E = ActiveTimers->end(); I != E; ++I) + (*I)->PeakMem = std::max((*I)->PeakMem, MemUsed-(*I)->PeakMemBase); +} + +//===----------------------------------------------------------------------===// +// NamedRegionTimer Implementation +//===----------------------------------------------------------------------===// + +static ManagedStatic > NamedTimers; + +static Timer &getNamedRegionTimer(const std::string &Name) { + std::map::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; +} + +NamedRegionTimer::NamedRegionTimer(const std::string &Name) + : TimeRegion(getNamedRegionTimer(Name)) {} + + //===----------------------------------------------------------------------===// // TimerGroup Implementation //===----------------------------------------------------------------------===// -static void printVal(double Val, double Total) { +// 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... - fprintf(stderr, " ----- "); - else - fprintf(stderr, " %7.4f (%5.1f%%)", Val, Val*100/Total); + OS << " ----- "; + else { + OS << " "; + printAlignedFP(Val, 4, 7, OS); + OS << " ("; + printAlignedFP(Val*100/Total, 1, 5, OS); + OS << "%)"; + } } -void Timer::print(const Timer &Total) { +void Timer::print(const Timer &Total, std::ostream &OS) { if (Total.UserTime) - printVal(UserTime, Total.UserTime); + printVal(UserTime, Total.UserTime, OS); if (Total.SystemTime) - printVal(SystemTime, Total.SystemTime); + printVal(SystemTime, Total.SystemTime, OS); if (Total.getProcessTime()) - printVal(getProcessTime(), Total.getProcessTime()); - printVal(Elapsed, Total.Elapsed); - - fprintf(stderr, " "); + printVal(getProcessTime(), Total.getProcessTime(), OS); + printVal(Elapsed, Total.Elapsed, OS); + + OS << " "; - if (Total.MaxRSS) - fprintf(stderr, " %8ld ", MaxRSS); - std::cerr << Name << "\n"; + if (Total.MemUsed) { + OS.width(9); + OS << MemUsed << " "; + } + if (Total.PeakMem) { + if (PeakMem) { + OS.width(9); + OS << PeakMem << " "; + } else + OS << " "; + } + OS << Name << "\n"; Started = false; // Once printed, don't print again } +// GetLibSupportInfoOutputFile - Return a file stream to print our output on... +std::ostream * +llvm::GetLibSupportInfoOutputFile() { + std::string &LibSupportInfoOutputFilename = getLibSupportInfoOutputFilename(); + if (LibSupportInfoOutputFilename.empty()) + return cerr.stream(); + if (LibSupportInfoOutputFilename == "-") + return cout.stream(); + + std::ostream *Result = new std::ofstream(LibSupportInfoOutputFilename.c_str(), + std::ios::app); + if (!Result->good()) { + cerr << "Error opening info-output-file '" + << LibSupportInfoOutputFilename << " for appending!\n"; + delete Result; + return cerr.stream(); + } + return Result; +} + void TimerGroup::removeTimer() { if (--NumTimers == 0 && !TimersToPrint.empty()) { // Print timing report... @@ -152,44 +289,61 @@ void TimerGroup::removeTimer() { unsigned Padding = (80-Name.length())/2; if (Padding > 80) Padding = 0; // Don't allow "negative" numbers + std::ostream *OutStream = GetLibSupportInfoOutputFile(); + ++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... - std::cerr << "===" << std::string(73, '-') << "===\n" - << std::string(Padding, ' ') << Name << "\n" - << "===" << std::string(73, '-') - << "===\n Total Execution Time: " << Total.getProcessTime() - << " seconds (" << Total.getWallTime() - << " wall clock)\n\n"; + *OutStream << "===" << std::string(73, '-') << "===\n" + << std::string(Padding, ' ') << Name << "\n" + << "===" << 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: "; + + printAlignedFP(Total.getProcessTime(), 4, 5, *OutStream); + *OutStream << " seconds ("; + printAlignedFP(Total.getWallTime(), 4, 5, *OutStream); + *OutStream << " wall clock)\n"; + } + *OutStream << "\n"; if (Total.UserTime) - std::cerr << " ---User Time---"; + *OutStream << " ---User Time---"; if (Total.SystemTime) - std::cerr << " --System Time--"; + *OutStream << " --System Time--"; if (Total.getProcessTime()) - std::cerr << " --User+System--"; - std::cerr << " ---Wall Time---"; - - if (Total.getMaxRSS()) - std::cerr << " ---Mem---"; - std::cerr << " --- Name ---\n"; - + *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); - - Total.print(Total); - std::cerr << std::endl; // Flush output + TimersToPrint[i].print(Total, *OutStream); + + Total.print(Total, *OutStream); + *OutStream << std::endl; // Flush output } --NumTimers; TimersToPrint.clear(); + + if (OutStream != cerr.stream() && OutStream != cout.stream()) + delete OutStream; // Close the file... } // Delete default timer group! @@ -198,3 +352,4 @@ void TimerGroup::removeTimer() { DefaultTimerGroup = 0; } } +