mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-18 12:29:21 +00:00
Initial checkin: instrument code to get path execution frequency
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1805 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
0b8066c149
commit
070834a040
162
lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
Normal file
162
lib/Transforms/Instrumentation/ProfilePaths/ProfilePaths.cpp
Normal file
@ -0,0 +1,162 @@
|
||||
//===-- ProfilePaths.cpp - interface to insert instrumentation ---*- C++ -*--=//
|
||||
//
|
||||
// This inserts intrumentation for counting
|
||||
// execution of paths though a given method
|
||||
// Its implemented as a "Method" Pass, and called using opt
|
||||
//
|
||||
// This pass is implemented by using algorithms similar to
|
||||
// 1."Efficient Path Profiling": Ball, T. and Larus, J. R.,
|
||||
// Proceedings of Micro-29, Dec 1996, Paris, France.
|
||||
// 2."Efficiently Counting Program events with support for on-line
|
||||
// "queries": Ball T., ACM Transactions on Programming Languages
|
||||
// and systems, Sep 1994.
|
||||
//
|
||||
// The algorithms work on a Graph constructed over the nodes
|
||||
// made from Basic Blocks: The transformations then take place on
|
||||
// the constucted graph (implementation in Graph.cpp and GraphAuxillary.cpp)
|
||||
// and finally, appropriate instrumentation is placed over suitable edges.
|
||||
// (code inserted through EdgeCode.cpp).
|
||||
//
|
||||
// The algorithm inserts code such that every acyclic path in the CFG
|
||||
// of a method is identified through a unique number. the code insertion
|
||||
// is optimal in the sense that its inserted over a minimal set of edges. Also,
|
||||
// the algorithm makes sure than initialization, path increment and counter
|
||||
// update can be collapsed into minmimum number of edges.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Transforms/Instrumentation/ProfilePaths.h"
|
||||
#include "llvm/Transforms/UnifyMethodExitNodes.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "llvm/Method.h"
|
||||
#include "llvm/BasicBlock.h"
|
||||
#include "llvm/ConstantVals.h"
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/iMemory.h"
|
||||
#include "Graph.h"
|
||||
|
||||
using std::vector;
|
||||
|
||||
static Node *findBB(set<Node *> &st, BasicBlock *BB){
|
||||
for(set<Node *>::iterator si=st.begin(); si!=st.end(); ++si){
|
||||
if(((*si)->getElement())==BB){
|
||||
return *si;
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
//Per method pass for inserting counters and trigger code
|
||||
bool ProfilePaths::runOnMethod(Method *M){
|
||||
//Transform the cfg s.t. we have just one exit node
|
||||
BasicBlock *ExitNode =
|
||||
getAnalysis<UnifyMethodExitNodes>().getExitNode();
|
||||
|
||||
//iterating over BBs and making graph
|
||||
std::set<Node *> nodes;
|
||||
std::set<Edge> edges;
|
||||
Node *tmp;
|
||||
Node *exitNode, *startNode;
|
||||
|
||||
//The nodes must be uniquesly identified:
|
||||
//That is, no two nodes must hav same BB*
|
||||
|
||||
//First enter just nodes: later enter edges
|
||||
for (Method::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){
|
||||
Node *nd=new Node(*BB);
|
||||
nodes.insert(nd);
|
||||
if(*BB==ExitNode)
|
||||
exitNode=nd;
|
||||
if(*BB==M->front())
|
||||
startNode=nd;
|
||||
}
|
||||
|
||||
//now do it againto insert edges
|
||||
for (Method::iterator BB = M->begin(), BE=M->end(); BB != BE; ++BB){
|
||||
Node *nd=findBB(nodes, *BB);
|
||||
assert(nd && "No node for this edge!");
|
||||
for(BasicBlock::succ_iterator s=succ_begin(*BB), se=succ_end(*BB);
|
||||
s!=se; ++s){
|
||||
Node *nd2=findBB(nodes,*s);
|
||||
assert(nd2 && "No node for this edge!");
|
||||
Edge ed(nd,nd2,0);
|
||||
edges.insert(ed);
|
||||
}
|
||||
}
|
||||
|
||||
Graph g(nodes,edges, startNode, exitNode);
|
||||
|
||||
#ifdef DEBUG_PATH_PROFILES
|
||||
printGraph(g);
|
||||
#endif
|
||||
|
||||
BasicBlock *fr=M->front();
|
||||
|
||||
//If only one BB, don't instrument
|
||||
if (M->getBasicBlocks().size() == 1) {
|
||||
//The graph is made acyclic: this is done
|
||||
//by removing back edges for now, and adding them later on
|
||||
vector<Edge > be;
|
||||
g.getBackEdges(be);
|
||||
#ifdef DEBUG_PATH_PROFILES
|
||||
cerr<<"Backedges:"<<be.size()<<endl;
|
||||
#endif
|
||||
//Now we need to reflect the effect of back edges
|
||||
//This is done by adding dummy edges
|
||||
//If a->b is a back edge
|
||||
//Then we add 2 back edges for it:
|
||||
//1. from root->b (in vector stDummy)
|
||||
//and 2. from a->exit (in vector exDummy)
|
||||
vector<Edge > stDummy;
|
||||
vector<Edge > exDummy;
|
||||
addDummyEdges(stDummy, exDummy, g, be);
|
||||
|
||||
//Now, every edge in the graph is assigned a weight
|
||||
//This weight later adds on to assign path
|
||||
//numbers to different paths in the graph
|
||||
// All paths for now are acyclic,
|
||||
//since no back edges in the graph now
|
||||
//numPaths is the number of acyclic paths in the graph
|
||||
int numPaths=valueAssignmentToEdges(g);
|
||||
|
||||
//create instruction allocation r and count
|
||||
//r is the variable that'll act like an accumulator
|
||||
//all along the path, we just add edge values to r
|
||||
//and at the end, r reflects the path number
|
||||
//count is an array: count[x] would store
|
||||
//the number of executions of path numbered x
|
||||
Instruction *rVar=new
|
||||
AllocaInst(PointerType::get(Type::IntTy),
|
||||
ConstantUInt::get(Type::UIntTy,1),"R");
|
||||
|
||||
Instruction *countVar=new
|
||||
AllocaInst(PointerType::get(Type::IntTy),
|
||||
ConstantUInt::get(Type::UIntTy, numPaths), "Count");
|
||||
|
||||
//insert initialization code in first (entry) BB
|
||||
//this includes initializing r and count
|
||||
insertInTopBB(M->getEntryNode(),numPaths, rVar, countVar);
|
||||
|
||||
//now process the graph: get path numbers,
|
||||
//get increments along different paths,
|
||||
//and assign "increments" and "updates" (to r and count)
|
||||
//"optimally". Finally, insert llvm code along various edges
|
||||
processGraph(g, rVar, countVar, be, stDummy, exDummy);
|
||||
}
|
||||
|
||||
return true; // Always modifies method
|
||||
}
|
||||
|
||||
//Before this pass, make sure that there is only one
|
||||
//entry and only one exit node for the method in the CFG of the method
|
||||
void ProfilePaths::getAnalysisUsageInfo(Pass::AnalysisSet &Requires,
|
||||
Pass::AnalysisSet &Destroyed,
|
||||
Pass::AnalysisSet &Provided) {
|
||||
Requires.push_back(UnifyMethodExitNodes::ID);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user