#include "PassManagerT.h" // PassManagerT implementation
#include "llvm/Module.h"
#include "Support/STLExtras.h"
-#include "Support/CommandLine.h"
#include "Support/TypeInfo.h"
#include <typeinfo>
-#include <iostream>
-#include <sys/time.h>
#include <stdio.h>
+#include <sys/resource.h>
+#include <sys/unistd.h>
//===----------------------------------------------------------------------===//
// AnalysisID Class Implementation
//
-static std::vector<AnalysisID> CFGOnlyAnalyses;
-#if 0
-// Source of unique analysis ID #'s.
-unsigned AnalysisID::NextID = 0;
+static std::vector<const PassInfo*> CFGOnlyAnalyses;
-AnalysisID::AnalysisID(const AnalysisID &AID, bool DependsOnlyOnCFG) {
- ID = AID.ID; // Implement the copy ctor part...
- Constructor = AID.Constructor;
-
- // If this analysis only depends on the CFG of the function, add it to the CFG
- // only list...
- if (DependsOnlyOnCFG)
- CFGOnlyAnalyses.push_back(AID);
+void RegisterPassBase::setPreservesCFG() {
+ CFGOnlyAnalyses.push_back(PIObj);
}
-#endif
//===----------------------------------------------------------------------===//
// AnalysisResolver Class Implementation
EnableTiming("time-passes",
cl::desc("Time each pass, printing elapsed time for each on exit"));
-static double getTime() {
+static TimeRecord getTimeRecord() {
+ static unsigned long PageSize = 0;
+
+ if (PageSize == 0) {
+#ifdef _SC_PAGE_SIZE
+ PageSize = sysconf(_SC_PAGE_SIZE);
+#else
+#ifdef _SC_PAGESIZE
+ PageSize = sysconf(_SC_PAGESIZE);
+#else
+ PageSize = getpagesize();
+#endif
+#endif
+ }
+
+ struct rusage RU;
struct timeval T;
gettimeofday(&T, 0);
- return T.tv_sec + T.tv_usec/1000000.0;
+ if (getrusage(RUSAGE_SELF, &RU)) {
+ perror("getrusage call failed: -time-passes info incorrect!");
+ }
+
+ 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.MaxRSS = RU.ru_maxrss*PageSize;
+
+ return Result;
+}
+
+void TimeRecord::passStart(const TimeRecord &T) {
+ Elapsed -= T.Elapsed;
+ UserTime -= T.UserTime;
+ SystemTime -= T.SystemTime;
+ RSSTemp = T.MaxRSS;
+}
+
+void TimeRecord::passEnd(const TimeRecord &T) {
+ Elapsed += T.Elapsed;
+ UserTime += T.UserTime;
+ SystemTime += T.SystemTime;
+ RSSTemp = T.MaxRSS - RSSTemp;
+ MaxRSS = std::max(MaxRSS, RSSTemp);
+}
+
+void TimeRecord::print(const char *PassName, const TimeRecord &Total) const {
+ fprintf(stderr,
+ " %7.4f (%5.1f%%) %7.4f (%5.1f%%) %7.4f (%5.1f%%) %7.4f (%5.1f%%) ",
+ UserTime , UserTime *100/Total.UserTime,
+ SystemTime, SystemTime*100/Total.SystemTime,
+ UserTime+SystemTime, (UserTime+SystemTime)*100/(Total.UserTime+Total.SystemTime),
+ Elapsed , Elapsed *100/Total.Elapsed);
+
+ if (Total.MaxRSS)
+ std::cerr << MaxRSS << "\t";
+ std::cerr << PassName << "\n";
}
+
// Create method. If Timing is enabled, this creates and returns a new timing
// object, otherwise it returns null.
//
return EnableTiming ? new TimingInfo() : 0;
}
-void TimingInfo::passStarted(Pass *P) { TimingData[P] -= getTime(); }
-void TimingInfo::passEnded(Pass *P) { TimingData[P] += getTime(); }
+void TimingInfo::passStarted(Pass *P) {
+ TimingData[P].passStart(getTimeRecord());
+}
+void TimingInfo::passEnded(Pass *P) {
+ TimingData[P].passEnd(getTimeRecord());
+}
+void TimeRecord::sum(const TimeRecord &TR) {
+ Elapsed += TR.Elapsed;
+ UserTime += TR.UserTime;
+ SystemTime += TR.SystemTime;
+ MaxRSS += TR.MaxRSS;
+}
// TimingDtor - Print out information about timing information
TimingInfo::~TimingInfo() {
// Iterate over all of the data, converting it into the dual of the data map,
// so that the data is sorted by amount of time taken, instead of pointer.
//
- std::vector<std::pair<double, Pass*> > Data;
- double TotalTime = 0;
- for (std::map<Pass*, double>::iterator I = TimingData.begin(),
+ std::vector<std::pair<TimeRecord, Pass*> > Data;
+ TimeRecord Total;
+ for (std::map<Pass*, TimeRecord>::iterator I = TimingData.begin(),
E = TimingData.end(); I != E; ++I)
// Throw out results for "grouping" pass managers...
if (!dynamic_cast<AnalysisResolver*>(I->first)) {
Data.push_back(std::make_pair(I->second, I->first));
- TotalTime += I->second;
+ Total.sum(I->second);
}
// Sort the data by time as the primary key, in reverse order...
- std::sort(Data.begin(), Data.end(), std::greater<std::pair<double, Pass*> >());
+ std::sort(Data.begin(), Data.end(),
+ std::greater<std::pair<TimeRecord, Pass*> >());
// Print out timing header...
std::cerr << std::string(79, '=') << "\n"
- << " ... Pass execution timing report ...\n"
- << std::string(79, '=') << "\n Total Execution Time: " << TotalTime
- << " seconds\n\n % Time: Seconds:\tPass Name:\n";
+ << " ... Pass execution timing report ...\n"
+ << std::string(79, '=') << "\n Total Execution Time: "
+ << (Total.UserTime+Total.SystemTime) << " seconds ("
+ << Total.Elapsed << " wall clock)\n\n ---User Time--- "
+ << "--System Time-- --User+System-- ---Wall Time---";
- // Loop through all of the timing data, printing it out...
- for (unsigned i = 0, e = Data.size(); i != e; ++i) {
- fprintf(stderr, " %6.2f%% %fs\t%s\n", Data[i].first*100 / TotalTime,
- Data[i].first, Data[i].second->getPassName());
- }
- std::cerr << " 100.00% " << TotalTime << "s\tTOTAL\n"
- << std::string(79, '=') << "\n";
-}
+ if (Total.MaxRSS)
+ std::cerr << " ---Mem---";
+ std::cerr << " --- Pass Name ---\n";
+ // Loop through all of the timing data, printing it out...
+ for (unsigned i = 0, e = Data.size(); i != e; ++i)
+ Data[i].first.print(Data[i].second->getPassName(), Total);
-//===----------------------------------------------------------------------===//
-// Pass debugging information. Often it is useful to find out what pass is
-// running when a crash occurs in a utility. When this library is compiled with
-// debugging on, a command line option (--debug-pass) is enabled that causes the
-// pass name to be printed before it executes.
-//
+ Total.print("TOTAL", Total);
+}
-// Different debug levels that can be enabled...
-enum PassDebugLevel {
- None, Structure, Executions, Details
-};
-static cl::opt<enum PassDebugLevel>
-PassDebugging("debug-pass", cl::Hidden,
- cl::desc("Print PassManager debugging information"),
- cl::values(
- clEnumVal(None , "disable debug output"),
- // TODO: add option to print out pass names "PassOptions"
- clEnumVal(Structure , "print pass structure before run()"),
- clEnumVal(Executions, "print pass name before it is executed"),
- clEnumVal(Details , "print pass details when it is executed"),
- 0));
+void PMDebug::PrintArgumentInformation(const Pass *P) {
+ // Print out passes in pass manager...
+ if (const AnalysisResolver *PM = dynamic_cast<const AnalysisResolver*>(P)) {
+ for (unsigned i = 0, e = PM->getNumContainedPasses(); i != e; ++i)
+ PrintArgumentInformation(PM->getContainedPass(i));
-void PMDebug::PrintPassStructure(Pass *P) {
- if (PassDebugging >= Structure)
- P->dumpPassStructure();
+ } else { // Normal pass. Print argument information...
+ // Print out arguments for registered passes that are _optimizations_
+ if (const PassInfo *PI = P->getPassInfo())
+ if (PI->getPassType() & PassInfo::Optimization)
+ std::cerr << " -" << PI->getPassArgument();
+ }
}
void PMDebug::PrintPassInformation(unsigned Depth, const char *Action,
Pass *P, const std::vector<AnalysisID> &Set){
if (PassDebugging >= Details && !Set.empty()) {
std::cerr << (void*)P << std::string(Depth*2+3, ' ') << Msg << " Analyses:";
- for (unsigned i = 0; i != Set.size(); ++i) {
- // FIXME: This can use the local pass map!
- Pass *P = Set[i]->createPass(); // Good thing this is just debug code...
- std::cerr << " " << P->getPassName();
- delete P;
- }
+ for (unsigned i = 0; i != Set.size(); ++i)
+ std::cerr << " " << Set[i]->getPassName();
std::cerr << "\n";
}
}
-// dumpPassStructure - Implement the -debug-passes=Structure option
-void Pass::dumpPassStructure(unsigned Offset) {
- std::cerr << std::string(Offset*2, ' ') << getPassName() << "\n";
-}
-
-
//===----------------------------------------------------------------------===//
// Pass Implementation
//
PM->addPass(this, AU);
}
+// dumpPassStructure - Implement the -debug-passes=Structure option
+void Pass::dumpPassStructure(unsigned Offset) {
+ std::cerr << std::string(Offset*2, ' ') << getPassName() << "\n";
+}
// getPassName - Use C++ RTTI to get a SOMEWHAT intelligable name for the pass.
//
-const char *Pass::getPassName() const { return typeid(*this).name(); }
+const char *Pass::getPassName() const {
+ if (const PassInfo *PI = getPassInfo())
+ return PI->getPassName();
+ return typeid(*this).name();
+}
// print - Print out the internal state of the pass. This is called by Analyse
// to print out the contents of an analysis. Otherwise it is not neccesary to
// getPassInfo - Return the PassInfo data structure that corresponds to this
// pass...
const PassInfo *Pass::getPassInfo() const {
- assert(PassInfoMap && "PassInfoMap not constructed yet??");
- std::map<TypeInfo, PassInfo*>::iterator I =
- PassInfoMap->find(typeid(*this));
- assert(I != PassInfoMap->end() && "Pass has not been registered!");
- return I->second;
+ if (PassInfoCache) return PassInfoCache;
+ if (PassInfoMap == 0) return 0;
+ std::map<TypeInfo, PassInfo*>::iterator I = PassInfoMap->find(typeid(*this));
+ return (I != PassInfoMap->end()) ? I->second : 0;
}
void RegisterPassBase::registerPass(PassInfo *PI) {