RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-10-19 11:02:59 +02:00
Code Issues Projects Releases Wiki Activity

Timer: Fix doxygen comments, use member initializer; NFC

Browse Source 
llvm-svn: 284181
This commit is contained in:
Matthias Braun 2016-10-14 00:17:19 +00:00
parent 6b1749d39a
commit ee622c1f15
2 changed files with 50 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
include/llvm/Support/Timer.h
View File

@ -24,17 +24,17 @@ class TimerGroup;
class raw_ostream;
class TimeRecord {
double WallTime; // Wall clock time elapsed in seconds
double UserTime; // User time elapsed
double SystemTime; // System time elapsed
ssize_t MemUsed; // Memory allocated (in bytes)
double WallTime; ///< Wall clock time elapsed in seconds.
double UserTime; ///< User time elapsed.
double SystemTime; ///< System time elapsed.
ssize_t MemUsed; ///< Memory allocated (in bytes).
public:
TimeRecord() : WallTime(0), UserTime(0), SystemTime(0), MemUsed(0) {}
/// getCurrentTime - Get the current time and memory usage. If Start is true
/// we get the memory usage before the time, otherwise we get time before
/// memory usage. This matters if the time to get the memory usage is
/// significant and shouldn't be counted as part of a duration.
/// Get the current time and memory usage. If Start is true we get the memory
/// usage before the time, otherwise we get time before memory usage. This
/// matters if the time to get the memory usage is significant and shouldn't
/// be counted as part of a duration.
static TimeRecord getCurrentTime(bool Start = true);
double getProcessTime() const { return UserTime + SystemTime; }
@ -43,7 +43,6 @@ public:
double getWallTime() const { return WallTime; }
ssize_t getMemUsed() const { return MemUsed; }
// operator< - Allow sorting.
bool operator<(const TimeRecord &T) const {
// Sort by Wall Time elapsed, as it is the only thing really accurate
return WallTime < T.WallTime;
@ -67,27 +66,27 @@ public:
void print(const TimeRecord &Total, raw_ostream &OS) const;
};
/// Timer - This class is used to track the amount of time spent between
/// invocations of its startTimer()/stopTimer() methods. Given appropriate OS
/// support it can also keep track of the RSS of the program at various points.
/// By default, the Timer will print the amount of time it has captured to
/// standard error when the last timer is destroyed, otherwise it is printed
/// when its TimerGroup is destroyed. Timers do not print their information
/// if they are never started.
///
/// This class is used to track the amount of time spent between invocations of
/// its startTimer()/stopTimer() methods. Given appropriate OS support it can
/// also keep track of the RSS of the program at various points. By default,
/// the Timer will print the amount of time it has captured to standard error
/// when the last timer is destroyed, otherwise it is printed when its
/// TimerGroup is destroyed. Timers do not print their information if they are
/// never started.
class Timer {
TimeRecord Time; // The total time captured
TimeRecord StartTime; // The time startTimer() was last called
std::string Name; // The name of this time variable.
bool Running; // Is the timer currently running?
bool Triggered; // Has the timer ever been triggered?
TimerGroup *TG; // The TimerGroup this Timer is in.
TimeRecord Time; ///< The total time captured.
TimeRecord StartTime; ///< The time startTimer() was last called.
std::string Name; ///< The name of this time variable.
bool Running; ///< Is the timer currently running?
bool Triggered; ///< Has the timer ever been triggered?
TimerGroup *TG = nullptr; ///< The TimerGroup this Timer is in.
Timer **Prev, *Next; // Doubly linked list of timers in the group.
Timer **Prev; ///< Pointer to \p Next of previous timer in group.
Timer *Next; ///< Next timer in the group.
public:
explicit Timer(StringRef N) : TG(nullptr) { init(N); }
Timer(StringRef N, TimerGroup &tg) : TG(nullptr) { init(N, tg); }
Timer(const Timer &RHS) : TG(nullptr) {
explicit Timer(StringRef N) { init(N); }
Timer(StringRef N, TimerGroup &tg) { init(N, tg); }
Timer(const Timer &RHS) {
assert(!RHS.TG && "Can only copy uninitialized timers");
}
const Timer &operator=(const Timer &T) {
@ -96,8 +95,8 @@ public:
}
~Timer();
// Create an uninitialized timer, client must use 'init'.
explicit Timer() : TG(nullptr) {}
/// Create an uninitialized timer, client must use 'init'.
explicit Timer() {}
void init(StringRef N);
void init(StringRef N, TimerGroup &tg);
@ -132,7 +131,6 @@ private:
/// stopTimer() methods of the Timer class. When the object is constructed, it
/// starts the timer specified as its argument. When it is destroyed, it stops
/// the relevant timer. This makes it easy to time a region of code.
///
class TimeRegion {
Timer *T;
TimeRegion(const TimeRegion &) = delete;
@ -149,11 +147,10 @@ public:
}
};
/// NamedRegionTimer - This class is basically a combination of TimeRegion and
/// Timer. It allows you to declare a new timer, AND specify the region to
/// time, all in one statement. All timers with the same name are merged. This
/// is primarily used for debugging and for hunting performance problems.
///
/// This class is basically a combination of TimeRegion and Timer. It allows
/// you to declare a new timer, AND specify the region to time, all in one
/// statement. All timers with the same name are merged. This is primarily
/// used for debugging and for hunting performance problems.
struct NamedRegionTimer : public TimeRegion {
explicit NamedRegionTimer(StringRef Name,
bool Enabled = true);
@ -165,13 +162,13 @@ struct NamedRegionTimer : public TimeRegion {
/// report that is printed when the TimerGroup is destroyed. It is illegal to
/// destroy a TimerGroup object before all of the Timers in it are gone. A
/// TimerGroup can be specified for a newly created timer in its constructor.
///
class TimerGroup {
std::string Name;
Timer *FirstTimer; // First timer in the group.
Timer *FirstTimer = nullptr; ///< First timer in the group.
std::vector<std::pair<TimeRecord, std::string>> TimersToPrint;
TimerGroup **Prev, *Next; // Doubly linked list of TimerGroup's.
TimerGroup **Prev; ///< Pointer to Next field of previous timergroup in list.
TimerGroup *Next; ///< Pointer to next timergroup in list.
TimerGroup(const TimerGroup &TG) = delete;
void operator=(const TimerGroup &TG) = delete;
@ -181,10 +178,10 @@ public:
void setName(StringRef name) { Name.assign(name.begin(), name.end()); }
/// print - Print any started timers in this group and zero them.
/// Print any started timers in this group and zero them.
void print(raw_ostream &OS);
/// printAll - This static method prints all timers and clears them all out.
/// This static method prints all timers and clears them all out.
static void printAll(raw_ostream &OS);
private:
@ -194,6 +191,6 @@ private:
void PrintQueuedTimers(raw_ostream &OS);
};
} // End llvm namespace
} // end namespace llvm
#endif

28
lib/Support/Timer.cpp
View File

@ -7,7 +7,7 @@
//
//===----------------------------------------------------------------------===//
//
// Interval Timing implementation.
/// \file Interval Timing implementation.
//
//===----------------------------------------------------------------------===//
@ -23,14 +23,13 @@
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
// 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.
// 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<std::string> LibSupportInfoOutputFilename;
static std::string &getLibSupportInfoOutputFilename() {
return *LibSupportInfoOutputFilename;
@ -50,7 +49,6 @@ namespace {
cl::Hidden, cl::location(getLibSupportInfoOutputFilename()));
}
// Return a file stream to print our output on.
std::unique_ptr<raw_fd_ostream> llvm::CreateInfoOutputFile() {
const std::string &OutputFilename = getLibSupportInfoOutputFilename();
if (OutputFilename.empty())
@ -234,12 +232,12 @@ NamedRegionTimer::NamedRegionTimer(StringRef Name, StringRef GroupName,
// TimerGroup Implementation
//===----------------------------------------------------------------------===//
/// TimerGroupList - This is the global list of TimerGroups, maintained by the
/// TimerGroup ctor/dtor and is protected by the TimerLock lock.
/// This is the global list of TimerGroups, maintained by the TimerGroup
/// ctor/dtor and is protected by the TimerLock lock.
static TimerGroup *TimerGroupList = nullptr;
TimerGroup::TimerGroup(StringRef name)
: Name(name.begin(), name.end()), FirstTimer(nullptr) {
: Name(name.begin(), name.end()) {
// Add the group to TimerGroupList.
sys::SmartScopedLock<true> L(*TimerLock);
@ -347,7 +345,6 @@ void TimerGroup::PrintQueuedTimers(raw_ostream &OS) {
TimersToPrint.clear();
}
/// print - Print any started timers in this group and zero them.
void TimerGroup::print(raw_ostream &OS) {
sys::SmartScopedLock<true> L(*TimerLock);
@ -356,7 +353,7 @@ void TimerGroup::print(raw_ostream &OS) {
for (Timer *T = FirstTimer; T; T = T->Next) {
if (!T->hasTriggered()) continue;
TimersToPrint.emplace_back(T->Time, T->Name);
// Clear out the time.
T->clear();
}
@ -366,7 +363,6 @@ void TimerGroup::print(raw_ostream &OS) {
PrintQueuedTimers(OS);
}
/// printAll - This static method prints all timers and clears them all out.
void TimerGroup::printAll(raw_ostream &OS) {
sys::SmartScopedLock<true> L(*TimerLock);