RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-06 12:26:45 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

This patch cleans up the ProfileInfo by

Browse Source 
*) introducing new data type and export function of edge info for whole function (preparation for next patch).
*) renaming variables to make clear distinction between data and containers that contain this data.
*) updated comments and whitespaces.
*) made ProfileInfo::MissingValue a double (as it should be...).

(Discussed at http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20090817/084955.html.)


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@79940 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Andreas Neustifter 2009-08-24 21:37:48 +00:00
parent fd7a918e58
commit 96135b617a
2 changed files with 21 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
include/llvm/Analysis/ProfileInfo.h
View File

@ -36,20 +36,21 @@ namespace llvm {
public: public:
// Types for handling profiling information. // Types for handling profiling information.
typedef std::pair<const BasicBlock*, const BasicBlock*> Edge; typedef std::pair<const BasicBlock*, const BasicBlock*> Edge;
typedef std::map<Edge, double> EdgeCounts; typedef std::pair<Edge, double> EdgeWeight;
typedef std::map<Edge, double> EdgeWeights;
typedef std::map<const BasicBlock*, double> BlockCounts; typedef std::map<const BasicBlock*, double> BlockCounts;
protected: protected:
// EdgeCounts - Count the number of times a transition between two blocks is // EdgeInformation - Count the number of times a transition between two
// executed. As a special case, we also hold an edge from the null // blocks is executed. As a special case, we also hold an edge from the
// BasicBlock to the entry block to indicate how many times the function was // null BasicBlock to the entry block to indicate how many times the
// entered. // function was entered.
std::map<const Function*, EdgeCounts> EdgeInformation; std::map<const Function*, EdgeWeights> EdgeInformation;
// BlockCounts - Count the number of times a block is executed. // BlockInformation - Count the number of times a block is executed.
std::map<const Function*, BlockCounts> BlockInformation; std::map<const Function*, BlockCounts> BlockInformation;
// FunctionCounts - Count the number of times a function is executed. // FunctionInformation - Count the number of times a function is executed.
std::map<const Function*, double> FunctionInformation; std::map<const Function*, double> FunctionInformation;
public: public:
static char ID; // Class identification, replacement for typeinfo static char ID; // Class identification, replacement for typeinfo
@ -57,7 +58,7 @@ namespace llvm {
// MissingValue - The value that is returned for execution counts in case // MissingValue - The value that is returned for execution counts in case
// no value is available. // no value is available.
static const int MissingValue = -1; static const double MissingValue;
// getFunction() - Returns the Function for an Edge, checking for validity. // getFunction() - Returns the Function for an Edge, checking for validity.
static const Function* getFunction(Edge e) { static const Function* getFunction(Edge e) {
@ -66,7 +67,7 @@ namespace llvm {
} }
// getEdge() - Creates an Edge from two BasicBlocks. // getEdge() - Creates an Edge from two BasicBlocks.
static Edge getEdge(const BasicBlock* Src, const BasicBlock* Dest) { static Edge getEdge(const BasicBlock *Src, const BasicBlock *Dest) {
return std::make_pair(Src, Dest); return std::make_pair(Src, Dest);
} }
@ -78,16 +79,20 @@ namespace llvm {
double getExecutionCount(const BasicBlock *BB); double getExecutionCount(const BasicBlock *BB);
double getEdgeWeight(Edge e) const { double getEdgeWeight(Edge e) const {
std::map<const Function*, EdgeCounts>::const_iterator J = std::map<const Function*, EdgeWeights>::const_iterator J =
EdgeInformation.find(getFunction(e)); EdgeInformation.find(getFunction(e));
if (J == EdgeInformation.end()) return MissingValue; if (J == EdgeInformation.end()) return MissingValue;
EdgeCounts::const_iterator I = J->second.find(e); EdgeWeights::const_iterator I = J->second.find(e);
if (I == J->second.end()) return MissingValue; if (I == J->second.end()) return MissingValue;
return I->second; return I->second;
} }
EdgeWeights &getEdgeWeights (const Function *F) {
return EdgeInformation[F];
}
//===------------------------------------------------------------------===// //===------------------------------------------------------------------===//
/// Analysis Update Methods /// Analysis Update Methods
/// ///

6
lib/Analysis/ProfileInfo.cpp
View File

@ -26,6 +26,8 @@ char ProfileInfo::ID = 0;
ProfileInfo::~ProfileInfo() {} ProfileInfo::~ProfileInfo() {}
const double ProfileInfo::MissingValue = -1;
double ProfileInfo::getExecutionCount(const BasicBlock *BB) { double ProfileInfo::getExecutionCount(const BasicBlock *BB) {
std::map<const Function*, BlockCounts>::iterator J = std::map<const Function*, BlockCounts>::iterator J =
BlockInformation.find(BB->getParent()); BlockInformation.find(BB->getParent());
@ -60,7 +62,7 @@ double ProfileInfo::getExecutionCount(const BasicBlock *BB) {
Count += w; Count += w;
} }
BlockInformation[BB->getParent()][BB] = Count; if (Count != MissingValue) BlockInformation[BB->getParent()][BB] = Count;
return Count; return Count;
} }
@ -72,7 +74,7 @@ double ProfileInfo::getExecutionCount(const Function *F) {
return J->second; return J->second;
double Count = getExecutionCount(&F->getEntryBlock()); double Count = getExecutionCount(&F->getEntryBlock());
FunctionInformation[F] = Count; if (Count != MissingValue) FunctionInformation[F] = Count;
return Count; return Count;
} }