mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-23 02:29:18 +00:00
revert r99862 which is causing FNT failures.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@99870 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
9fa0eff30a
commit
0d2725ad69
@ -413,6 +413,7 @@ private:
|
||||
/// It batches all function passes and basic block pass managers together and
|
||||
/// sequence them to process one function at a time before processing next
|
||||
/// function.
|
||||
|
||||
class FPPassManager : public ModulePass, public PMDataManager {
|
||||
public:
|
||||
static char ID;
|
||||
@ -461,7 +462,8 @@ public:
|
||||
}
|
||||
};
|
||||
|
||||
Timer *getPassTimer(Pass *);
|
||||
extern Timer *StartPassTimer(Pass *);
|
||||
extern void StopPassTimer(Pass *, Timer *);
|
||||
|
||||
}
|
||||
|
||||
|
@ -16,62 +16,15 @@
|
||||
#define LLVM_SUPPORT_TIMER_H
|
||||
|
||||
#include "llvm/System/DataTypes.h"
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class Timer;
|
||||
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)
|
||||
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.
|
||||
static TimeRecord getCurrentTime(bool Start = true);
|
||||
|
||||
double getProcessTime() const { return UserTime+SystemTime; }
|
||||
double getUserTime() const { return UserTime; }
|
||||
double getSystemTime() const { return SystemTime; }
|
||||
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;
|
||||
}
|
||||
|
||||
void operator+=(const TimeRecord &RHS) {
|
||||
WallTime += RHS.WallTime;
|
||||
UserTime += RHS.UserTime;
|
||||
SystemTime += RHS.SystemTime;
|
||||
MemUsed += RHS.MemUsed;
|
||||
}
|
||||
void operator-=(const TimeRecord &RHS) {
|
||||
WallTime -= RHS.WallTime;
|
||||
UserTime -= RHS.UserTime;
|
||||
SystemTime -= RHS.SystemTime;
|
||||
MemUsed -= RHS.MemUsed;
|
||||
}
|
||||
|
||||
/// print - Print the current timer to standard error, and reset the "Started"
|
||||
/// flag.
|
||||
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.
|
||||
@ -81,29 +34,34 @@ public:
|
||||
/// if they are never started.
|
||||
///
|
||||
class Timer {
|
||||
TimeRecord Time;
|
||||
double Elapsed; // Wall clock time elapsed in seconds
|
||||
double UserTime; // User time elapsed
|
||||
double SystemTime; // System time elapsed
|
||||
ssize_t MemUsed; // Memory allocated (in bytes)
|
||||
std::string Name; // The name of this time variable.
|
||||
bool Started; // Has this time variable ever been started?
|
||||
TimerGroup *TG; // The TimerGroup this Timer is in.
|
||||
public:
|
||||
explicit Timer(const std::string &N) : TG(0) { init(N); }
|
||||
Timer(const std::string &N, TimerGroup &tg) : TG(0) { init(N, tg); }
|
||||
Timer(const Timer &RHS) : TG(0) {
|
||||
assert(RHS.TG == 0 && "Can only copy uninitialized timers");
|
||||
}
|
||||
const Timer &operator=(const Timer &T) {
|
||||
assert(TG == 0 && T.TG == 0 && "Can only assign uninit timers");
|
||||
return *this;
|
||||
}
|
||||
explicit Timer(const std::string &N);
|
||||
Timer(const std::string &N, TimerGroup &tg);
|
||||
Timer(const Timer &T);
|
||||
~Timer();
|
||||
|
||||
// Create an uninitialized timer, client must use 'init'.
|
||||
explicit Timer() : TG(0) {}
|
||||
void init(const std::string &N);
|
||||
void init(const std::string &N, TimerGroup &tg);
|
||||
private:
|
||||
double getProcessTime() const { return UserTime+SystemTime; }
|
||||
double getWallTime() const { return Elapsed; }
|
||||
ssize_t getMemUsed() const { return MemUsed; }
|
||||
public:
|
||||
std::string getName() const { return Name; }
|
||||
|
||||
const std::string &getName() const { return Name; }
|
||||
bool isInitialized() const { return TG != 0; }
|
||||
const Timer &operator=(const Timer &T);
|
||||
|
||||
// operator< - Allow sorting.
|
||||
bool operator<(const Timer &T) const {
|
||||
// Sort by Wall Time elapsed, as it is the only thing really accurate
|
||||
return Elapsed < T.Elapsed;
|
||||
}
|
||||
bool operator>(const Timer &T) const { return T.operator<(*this); }
|
||||
|
||||
/// startTimer - Start the timer running. Time between calls to
|
||||
/// startTimer/stopTimer is counted by the Timer class. Note that these calls
|
||||
@ -115,8 +73,19 @@ public:
|
||||
///
|
||||
void stopTimer();
|
||||
|
||||
/// print - Print the current timer to standard error, and reset the "Started"
|
||||
/// flag.
|
||||
void print(const Timer &Total, raw_ostream &OS);
|
||||
|
||||
private:
|
||||
friend class TimerGroup;
|
||||
|
||||
// Copy ctor, initialize with no TG member.
|
||||
Timer(bool, const Timer &T);
|
||||
|
||||
/// sum - Add the time accumulated in the specified timer into this timer.
|
||||
///
|
||||
void sum(const Timer &T);
|
||||
};
|
||||
|
||||
|
||||
@ -163,13 +132,9 @@ struct NamedRegionTimer : public TimeRegion {
|
||||
class TimerGroup {
|
||||
std::string Name;
|
||||
unsigned NumTimers;
|
||||
std::vector<std::pair<TimeRecord, std::string> > TimersToPrint;
|
||||
std::vector<Timer> TimersToPrint;
|
||||
public:
|
||||
explicit TimerGroup(const std::string &name) : Name(name), NumTimers(0) {}
|
||||
explicit TimerGroup() : NumTimers(0) {}
|
||||
|
||||
void setName(const std::string &name) { Name = name; }
|
||||
|
||||
~TimerGroup() {
|
||||
assert(NumTimers == 0 &&
|
||||
"TimerGroup destroyed before all contained timers!");
|
||||
@ -179,7 +144,7 @@ private:
|
||||
friend class Timer;
|
||||
void addTimer();
|
||||
void removeTimer();
|
||||
void addTimerToPrint(const TimeRecord &T, const std::string &Name);
|
||||
void addTimerToPrint(const Timer &T);
|
||||
};
|
||||
|
||||
} // End llvm namespace
|
||||
|
@ -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 @@ bool CGPassManager::RunPassOnSCC(Pass *P, std::vector<CallGraphNode*> &CurSCC,
|
||||
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 @@ bool CGPassManager::RunPassOnSCC(Pass *P, std::vector<CallGraphNode*> &CurSCC,
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -14,7 +14,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Analysis/LoopPass.h"
|
||||
#include "llvm/Support/Timer.h"
|
||||
using namespace llvm;
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
@ -229,9 +228,9 @@ bool LPPassManager::runOnFunction(Function &F) {
|
||||
|
||||
{
|
||||
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 @@ bool LPPassManager::runOnFunction(Function &F) {
|
||||
// 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);
|
||||
|
@ -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 @@ static TimerGroup *getDefaultTimerGroup() {
|
||||
// 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 @@ static inline size_t getMemUsage() {
|
||||
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 @@ TimeRecord TimeRecord::getCurrentTime(bool Start) {
|
||||
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 @@ static ManagedStatic<std::vector<Timer*> > ActiveTimers;
|
||||
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::stopTimer() {
|
||||
}
|
||||
}
|
||||
|
||||
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 @@ static void printVal(double Val, double Total, raw_ostream &OS) {
|
||||
}
|
||||
}
|
||||
|
||||
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 @@ void TimeRecord::print(const TimeRecord &Total, raw_ostream &OS) const {
|
||||
// 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);
|
||||
Name2Timer::iterator I = NamedTimers->find(Name);
|
||||
if (I != NamedTimers->end())
|
||||
return I->second;
|
||||
|
||||
Timer &T = (*NamedTimers)[Name];
|
||||
if (!T.isInitialized())
|
||||
T.init(Name);
|
||||
return T;
|
||||
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 @@ void TimerGroup::removeTimer() {
|
||||
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 @@ void TimerGroup::removeTimer() {
|
||||
|
||||
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 @@ void TimerGroup::addTimer() {
|
||||
++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));
|
||||
}
|
||||
|
||||
|
@ -378,7 +378,7 @@ namespace {
|
||||
static ManagedStatic<sys::SmartMutex<true> > TimingInfoMutex;
|
||||
|
||||
class TimingInfo {
|
||||
DenseMap<Pass*, Timer> TimingData;
|
||||
std::map<Pass*, Timer> TimingData;
|
||||
TimerGroup TG;
|
||||
|
||||
public:
|
||||
@ -397,16 +397,19 @@ public:
|
||||
// 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 @@ void PMDataManager::verifyPreservedAnalysis(Pass *P) {
|
||||
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 @@ void PMDataManager::freePass(Pass *P, StringRef Msg,
|
||||
{
|
||||
// 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 @@ bool BBPassManager::runOnFunction(Function &F) {
|
||||
{
|
||||
// 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 @@ bool FPPassManager::runOnFunction(Function &F) {
|
||||
|
||||
{
|
||||
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 @@ MPPassManager::runOnModule(Module &M) {
|
||||
|
||||
{
|
||||
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 @@ void TimingInfo::createTheTimeInfo() {
|
||||
}
|
||||
|
||||
/// 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
|
||||
//
|
||||
|
Loading…
Reference in New Issue
Block a user