revert r99862 which is causing FNT failures.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@99870 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Analysis/IPA/CallGraphSCCPass.cpp b/lib/Analysis/IPA/CallGraphSCCPass.cpp
index 0f39f44..0e333d1 100644
--- a/lib/Analysis/IPA/CallGraphSCCPass.cpp
+++ b/lib/Analysis/IPA/CallGraphSCCPass.cpp
@@ -17,13 +17,12 @@
#define DEBUG_TYPE "cgscc-passmgr"
#include "llvm/CallGraphSCCPass.h"
-#include "llvm/IntrinsicInst.h"
-#include "llvm/Function.h"
-#include "llvm/PassManagers.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/ADT/SCCIterator.h"
+#include "llvm/PassManagers.h"
+#include "llvm/Function.h"
#include "llvm/Support/Debug.h"
-#include "llvm/Support/Timer.h"
+#include "llvm/IntrinsicInst.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
@@ -103,10 +102,9 @@
CallGraphUpToDate = true;
}
- {
- TimeRegion PassTimer(getPassTimer(CGSP));
- Changed = CGSP->runOnSCC(CurSCC);
- }
+ Timer *T = StartPassTimer(CGSP);
+ Changed = CGSP->runOnSCC(CurSCC);
+ StopPassTimer(CGSP, T);
// After the CGSCCPass is done, when assertions are enabled, use
// RefreshCallGraph to verify that the callgraph was correctly updated.
@@ -127,8 +125,9 @@
for (unsigned i = 0, e = CurSCC.size(); i != e; ++i) {
if (Function *F = CurSCC[i]->getFunction()) {
dumpPassInfo(P, EXECUTION_MSG, ON_FUNCTION_MSG, F->getName());
- TimeRegion PassTimer(getPassTimer(FPP));
+ Timer *T = StartPassTimer(FPP);
Changed |= FPP->runOnFunction(*F);
+ StopPassTimer(FPP, T);
}
}
diff --git a/lib/Analysis/LoopPass.cpp b/lib/Analysis/LoopPass.cpp
index f26c0eb..2d613f6 100644
--- a/lib/Analysis/LoopPass.cpp
+++ b/lib/Analysis/LoopPass.cpp
@@ -14,7 +14,6 @@
//===----------------------------------------------------------------------===//
#include "llvm/Analysis/LoopPass.h"
-#include "llvm/Support/Timer.h"
using namespace llvm;
//===----------------------------------------------------------------------===//
@@ -229,9 +228,9 @@
{
PassManagerPrettyStackEntry X(P, *CurrentLoop->getHeader());
- TimeRegion PassTimer(getPassTimer(P));
-
+ Timer *T = StartPassTimer(P);
Changed |= P->runOnLoop(CurrentLoop, *this);
+ StopPassTimer(P, T);
}
if (Changed)
@@ -246,10 +245,9 @@
// is a function pass and it's really expensive to verify every
// loop in the function every time. That level of checking can be
// enabled with the -verify-loop-info option.
- {
- TimeRegion PassTimer(getPassTimer(LI));
- CurrentLoop->verifyLoop();
- }
+ Timer *T = StartPassTimer(LI);
+ CurrentLoop->verifyLoop();
+ StopPassTimer(LI, T);
// Then call the regular verifyAnalysis functions.
verifyPreservedAnalysis(P);
diff --git a/lib/Support/Timer.cpp b/lib/Support/Timer.cpp
index 96f440a..317d5ac 100644
--- a/lib/Support/Timer.cpp
+++ b/lib/Support/Timer.cpp
@@ -19,7 +19,6 @@
#include "llvm/Support/Format.h"
#include "llvm/System/Mutex.h"
#include "llvm/System/Process.h"
-#include "llvm/ADT/StringMap.h"
#include <map>
using namespace llvm;
@@ -96,28 +95,37 @@
// Timer Implementation
//===----------------------------------------------------------------------===//
-void Timer::init(const std::string &N) {
- assert(TG == 0 && "Timer already initialized");
- Name = N;
- Started = false;
- TG = getDefaultTimerGroup();
+Timer::Timer(const std::string &N)
+ : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), 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;
+Timer::Timer(const std::string &N, TimerGroup &tg)
+ : Elapsed(0), UserTime(0), SystemTime(0), MemUsed(0), Name(N),
+ Started(false), TG(&tg) {
TG->addTimer();
}
+Timer::Timer(const Timer &T) {
+ TG = T.TG;
+ if (TG) TG->addTimer();
+ operator=(T);
+}
+
+// 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;
+}
+
Timer::~Timer() {
- if (!TG) return; // Never initialized.
+ if (!TG) return;
if (Started) {
Started = false;
- TG->addTimerToPrint(Time, Name);
+ TG->addTimerToPrint(*this);
}
TG->removeTimer();
}
@@ -128,7 +136,12 @@
return 0;
}
-TimeRecord TimeRecord::getCurrentTime(bool Start) {
+struct TimeRecord {
+ double Elapsed, UserTime, SystemTime;
+ ssize_t MemUsed;
+};
+
+static TimeRecord getTimeRecord(bool Start) {
TimeRecord Result;
sys::TimeValue now(0,0);
@@ -144,9 +157,9 @@
MemUsed = getMemUsage();
}
- Result.WallTime = now.seconds() + now.microseconds() / 1000000.0;
+ 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.SystemTime = sys.seconds() + sys.microseconds() / 1000000.0;
Result.MemUsed = MemUsed;
return Result;
}
@@ -156,11 +169,19 @@
void Timer::startTimer() {
Started = true;
ActiveTimers->push_back(this);
- Time -= TimeRecord::getCurrentTime(true);
+ TimeRecord TR = getTimeRecord(true);
+ Elapsed -= TR.Elapsed;
+ UserTime -= TR.UserTime;
+ SystemTime -= TR.SystemTime;
+ MemUsed -= TR.MemUsed;
}
void Timer::stopTimer() {
- Time += TimeRecord::getCurrentTime(false);
+ TimeRecord TR = getTimeRecord(false);
+ Elapsed += TR.Elapsed;
+ UserTime += TR.UserTime;
+ SystemTime += TR.SystemTime;
+ MemUsed += TR.MemUsed;
if (ActiveTimers->back() == this) {
ActiveTimers->pop_back();
@@ -172,6 +193,25 @@
}
}
+void Timer::sum(const Timer &T) {
+ Elapsed += T.Elapsed;
+ UserTime += T.UserTime;
+ SystemTime += T.SystemTime;
+ MemUsed += T.MemUsed;
+}
+
+const Timer &Timer::operator=(const Timer &T) {
+ Elapsed = T.Elapsed;
+ UserTime = T.UserTime;
+ SystemTime = T.SystemTime;
+ MemUsed = T.MemUsed;
+ Name = T.Name;
+ Started = T.Started;
+ assert(TG == T.TG && "Can only assign timers in the same TimerGroup!");
+ return *this;
+}
+
+
static void printVal(double Val, double Total, raw_ostream &OS) {
if (Total < 1e-7) // Avoid dividing by zero.
OS << " ----- ";
@@ -181,19 +221,23 @@
}
}
-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);
+void Timer::print(const Timer &Total, raw_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(getWallTime(), Total.getWallTime(), OS);
+ printVal(Elapsed, Total.Elapsed, OS);
OS << " ";
- if (Total.getMemUsed())
- OS << format("%9lld", (long long)getMemUsed()) << " ";
+ if (Total.MemUsed)
+ OS << format("%9lld", (long long)MemUsed) << " ";
+
+ OS << Name << "\n";
+
+ Started = false; // Once printed, don't print again
}
@@ -201,35 +245,40 @@
// NamedRegionTimer Implementation
//===----------------------------------------------------------------------===//
-typedef StringMap<Timer> Name2TimerMap;
-typedef StringMap<std::pair<TimerGroup, Name2TimerMap> > Name2PairMap;
+typedef std::map<std::string, Timer> Name2Timer;
+typedef std::map<std::string, std::pair<TimerGroup, Name2Timer> > Name2Pair;
-static ManagedStatic<Name2TimerMap> NamedTimers;
-static ManagedStatic<Name2PairMap> NamedGroupedTimers;
+static ManagedStatic<Name2Timer> NamedTimers;
+static ManagedStatic<Name2Pair> NamedGroupedTimers;
static Timer &getNamedRegionTimer(const std::string &Name) {
sys::SmartScopedLock<true> L(*TimerLock);
-
- Timer &T = (*NamedTimers)[Name];
- if (!T.isInitialized())
- T.init(Name);
- return T;
+ Name2Timer::iterator I = NamedTimers->find(Name);
+ if (I != NamedTimers->end())
+ return I->second;
+
+ return NamedTimers->insert(I, std::make_pair(Name, Timer(Name)))->second;
}
static Timer &getNamedRegionTimer(const std::string &Name,
const std::string &GroupName) {
sys::SmartScopedLock<true> L(*TimerLock);
- std::pair<TimerGroup, Name2TimerMap> &GroupEntry =
- (*NamedGroupedTimers)[GroupName];
+ Name2Pair::iterator I = NamedGroupedTimers->find(GroupName);
+ if (I == NamedGroupedTimers->end()) {
+ TimerGroup TG(GroupName);
+ std::pair<TimerGroup, Name2Timer> Pair(TG, Name2Timer());
+ I = NamedGroupedTimers->insert(I, std::make_pair(GroupName, Pair));
+ }
- if (GroupEntry.second.empty())
- GroupEntry.first.setName(GroupName);
+ Name2Timer::iterator J = I->second.second.find(Name);
+ if (J == I->second.second.end())
+ J = I->second.second.insert(J,
+ std::make_pair(Name,
+ Timer(Name,
+ I->second.first)));
- Timer &T = GroupEntry.second[Name];
- if (!T.isInitialized())
- T.init(Name);
- return T;
+ return J->second;
}
NamedRegionTimer::NamedRegionTimer(const std::string &Name)
@@ -249,7 +298,8 @@
return; // Don't print timing report.
// Sort the timers in descending order by amount of time taken.
- std::sort(TimersToPrint.begin(), TimersToPrint.end());
+ std::sort(TimersToPrint.begin(), TimersToPrint.end(),
+ std::greater<Timer>());
// Figure out how many spaces to indent TimerGroup name.
unsigned Padding = (80-Name.length())/2;
@@ -257,46 +307,50 @@
raw_ostream *OutStream = GetLibSupportInfoOutputFile();
- TimeRecord Total;
- for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
- Total += TimersToPrint[i].first;
+ ++NumTimers;
+ { // Scope to contain Total timer: don't allow total timer to drop us to
+ // zero timers.
+ Timer Total("TOTAL");
- // Print out timing header.
- *OutStream << "===" << std::string(73, '-') << "===\n";
- OutStream->indent(Padding) << Name << '\n';
- *OutStream << "===" << std::string(73, '-') << "===\n";
+ for (unsigned i = 0, e = TimersToPrint.size(); i != e; ++i)
+ Total.sum(TimersToPrint[i]);
- // 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";
+ // Print out timing header.
+ *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: ";
+ *OutStream << format("%5.4f", Total.getProcessTime()) << " seconds (";
+ *OutStream << format("%5.4f", Total.getWallTime()) << " wall clock)\n";
+ }
+ *OutStream << "\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---";
+ *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 << '\n';
+ OutStream->flush();
}
- *OutStream << "\n";
-
- 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';
- }
-
- Total.print(Total, *OutStream);
- *OutStream << "Total\n\n";
- OutStream->flush();
+ --NumTimers;
TimersToPrint.clear();
@@ -309,8 +363,8 @@
++NumTimers;
}
-void TimerGroup::addTimerToPrint(const TimeRecord &T, const std::string &Name) {
+void TimerGroup::addTimerToPrint(const Timer &T) {
sys::SmartScopedLock<true> L(*TimerLock);
- TimersToPrint.push_back(std::make_pair(T, Name));
+ TimersToPrint.push_back(Timer(true, T));
}
diff --git a/lib/VMCore/PassManager.cpp b/lib/VMCore/PassManager.cpp
index 6d83261..c4dfe14 100644
--- a/lib/VMCore/PassManager.cpp
+++ b/lib/VMCore/PassManager.cpp
@@ -378,7 +378,7 @@
static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
class TimingInfo {
- DenseMap<Pass*, Timer> TimingData;
+ std::map<Pass*, Timer> TimingData;
TimerGroup TG;
public:
@@ -397,16 +397,19 @@
// null. It may be called multiple times.
static void createTheTimeInfo();
- /// getPassTimer - Return the timer for the specified pass if it exists.
- Timer *getPassTimer(Pass *P) {
+ /// passStarted - This method creates a timer for the given pass if it doesn't
+ /// already have one, and starts the timer.
+ Timer *passStarted(Pass *P) {
if (P->getAsPMDataManager())
return 0;
sys::SmartScopedLock<true> Lock(*TimingInfoMutex);
- Timer &T = TimingData[P];
- if (!T.isInitialized())
- T.init(P->getPassName(), TG);
- return &T;
+ std::map<Pass*, Timer>::iterator I = TimingData.find(P);
+ if (I == TimingData.end())
+ I=TimingData.insert(std::make_pair(P, Timer(P->getPassName(), TG))).first;
+ Timer *T = &I->second;
+ T->startTimer();
+ return T;
}
};
@@ -701,8 +704,11 @@
E = PreservedSet.end(); I != E; ++I) {
AnalysisID AID = *I;
if (Pass *AP = findAnalysisPass(AID, true)) {
- TimeRegion PassTimer(getPassTimer(AP));
+
+ Timer *T = 0;
+ if (TheTimeInfo) T = TheTimeInfo->passStarted(AP);
AP->verifyAnalysis();
+ if (T) T->stopTimer();
}
}
}
@@ -786,9 +792,10 @@
{
// If the pass crashes releasing memory, remember this.
PassManagerPrettyStackEntry X(P);
- TimeRegion PassTimer(getPassTimer(P));
-
+
+ Timer *T = StartPassTimer(P);
P->releaseMemory();
+ StopPassTimer(P, T);
}
if (const PassInfo *PI = P->getPassInfo()) {
@@ -1121,9 +1128,10 @@
{
// If the pass crashes, remember this.
PassManagerPrettyStackEntry X(BP, *I);
- TimeRegion PassTimer(getPassTimer(BP));
-
+
+ Timer *T = StartPassTimer(BP);
LocalChanged |= BP->runOnBasicBlock(*I);
+ StopPassTimer(BP, T);
}
Changed |= LocalChanged;
@@ -1337,9 +1345,10 @@
{
PassManagerPrettyStackEntry X(FP, F);
- TimeRegion PassTimer(getPassTimer(FP));
+ Timer *T = StartPassTimer(FP);
LocalChanged |= FP->runOnFunction(F);
+ StopPassTimer(FP, T);
}
Changed |= LocalChanged;
@@ -1411,9 +1420,9 @@
{
PassManagerPrettyStackEntry X(MP, M);
- TimeRegion PassTimer(getPassTimer(MP));
-
+ Timer *T = StartPassTimer(MP);
LocalChanged |= MP->runOnModule(M);
+ StopPassTimer(MP, T);
}
Changed |= LocalChanged;
@@ -1550,12 +1559,17 @@
}
/// If TimingInfo is enabled then start pass timer.
-Timer *llvm::getPassTimer(Pass *P) {
+Timer *llvm::StartPassTimer(Pass *P) {
if (TheTimeInfo)
- return TheTimeInfo->getPassTimer(P);
+ return TheTimeInfo->passStarted(P);
return 0;
}
+/// If TimingInfo is enabled then stop pass timer.
+void llvm::StopPassTimer(Pass *P, Timer *T) {
+ if (T) T->stopTimer();
+}
+
//===----------------------------------------------------------------------===//
// PMStack implementation
//