6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-19 19:29:31 +00:00
Code Issues Projects Releases Wiki Activity

Incorporated changes in alloca and getElementPointer instruction

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3733 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Anand Shukla 2002-09-16 05:26:51 +00:00
parent ada50a5c1d
commit 6641995564
5 changed files with 254 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

91
lib/Transforms/Instrumentation/ProfilePaths/EdgeCode.cpp
View File

@ -16,7 +16,6 @@
#include "llvm/iOperators.h"
#include "llvm/iPHINode.h"
#include "llvm/Module.h"
#include <string.h>
#include <stdio.h>
#define INSERT_LOAD_COUNT
@ -27,11 +26,7 @@ using std::vector;
static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo,
Value *cnt, Instruction *InsertPos){
static int i=-1;
i++;
char gstr[100];
sprintf(gstr,"globalVar%d",i);
std::string globalVarName=gstr;
vector<const Type*> args;
//args.push_back(PointerType::get(Type::SByteTy));
args.push_back(Type::IntTy);
@ -39,39 +34,15 @@ static void getTriggerCode(Module *M, BasicBlock *BB, int MethNo, Value *pathNo,
args.push_back(Type::IntTy);
const FunctionType *MTy = FunctionType::get(Type::VoidTy, args, false);
// Function *triggerMeth = M->getOrInsertFunction("trigger", MTy);
Function *trigMeth = M->getOrInsertFunction("trigger", MTy);
assert(trigMeth && "trigger method could not be inserted!");
//if (Value *triggerMeth = ST->lookup(PointerType::get(MTy), "trigger")) {
//Function *trigMeth = cast<Function>(triggerMeth);
vector<Value *> trargs;
//pred_iterator piter=BB->pred_begin();
//std::string predName = "uu";//BB->getName();
//Constant *bbName=ConstantArray::get(predName);//BB->getName());
//GlobalVariable *gbl=new GlobalVariable(ArrayType::get(Type::SByteTy,
// predName.size()+1),
// true, true, bbName, gstr);
//M->getGlobalList().push_back(gbl);
//vector<Value *> elargs;
//elargs.push_back(ConstantSInt::get(Type::LongTy, 0));
//elargs.push_back(ConstantSInt::get(Type::LongTy, 0));
// commented out bb name frm which its called
//Instruction *getElmntInst=new GetElementPtrInst(gbl,elargs,"elmntInst");
//trargs.push_back(ConstantArray::get(BB->getName()));
//trargs.push_back(getElmntInst);
//trargs.push_back(bbName);
trargs.push_back(ConstantSInt::get(Type::IntTy,MethNo));
//trargs.push_back(ConstantSInt::get(Type::IntTy,-1));//erase this
trargs.push_back(pathNo);
trargs.push_back(cnt);
Instruction *callInst=new CallInst(trigMeth, trargs, "", InsertPos);
}
@ -83,7 +54,7 @@ void getEdgeCode::getCode(Instruction *rInst,
Function *M,
BasicBlock *BB, int numPaths, int MethNo){
Instruction *InsertPos = BB->begin();
Instruction *InsertPos = BB->getInstList().begin();
//case: r=k code to be inserted
switch(cond){
@ -149,10 +120,8 @@ void getEdgeCode::getCode(Instruction *rInst,
Value *val=ConstantSInt::get(Type::IntTy,inc);
Instruction *addIndex=BinaryOperator::
create(Instruction::Add, ldIndex, val,"ti2", InsertPos);
//erase following 1 line
//Value *valtemp=ConstantSInt::get(Type::IntTy,999);
//now load count[addIndex]
//now load count[addIndex]
Instruction *castInst=new CastInst(addIndex,
Type::LongTy,"ctin", InsertPos);
Instruction *Idx = new GetElementPtrInst(countInst,
@ -162,13 +131,11 @@ void getEdgeCode::getCode(Instruction *rInst,
Instruction *ldInst=new LoadInst(Idx, "ti3", InsertPos);
Value *cons=ConstantSInt::get(Type::IntTy,1);
//count[addIndex]++
Value *addIn = BinaryOperator::create(Instruction::Add, ldInst, cons,
"ti4", InsertPos);
Value *addIn = BinaryOperator::create(Instruction::Add, ldInst,
cons,"", InsertPos);
#ifdef INSERT_STORE
///*
new StoreInst(addIn, Idx, InsertPos);
//*/
Instruction *stInst = new StoreInst(addIn, Idx, InsertPos);
#endif
//insert trigger
@ -202,7 +169,6 @@ void getEdgeCode::getCode(Instruction *rInst,
//insert trigger
getTriggerCode(M->getParent(), BB, MethNo, ldIndex, addIn, InsertPos);
//end trigger code
break;
}
@ -252,6 +218,30 @@ void insertInTopBB(BasicBlock *front,
//store uint 0, uint *%R
new StoreInst(Int0, rVar, here);
if(front->getParent()->getName() == "main"){
//if its a main function, do the following!
//A global variable: %llvm_threshold
//%llvm_threshold = uninitialized global int
GlobalVariable *threshold = new GlobalVariable(Type::IntTy, false, true, 0,
"reopt_threshold");
front->getParent()->getParent()->getGlobalList().push_back(threshold);
vector<const Type*> initialize_args;
initialize_args.push_back(PointerType::get(Type::IntTy));
const FunctionType *Fty = FunctionType::get(Type::VoidTy, initialize_args,
false);
Function *initialMeth = front->getParent()->getParent()->getOrInsertFunction("reoptimizerInitialize", Fty);
assert(initialMeth && "Initialize method could not be inserted!");
vector<Value *> trargs;
trargs.push_back(threshold);
new CallInst(initialMeth, trargs, "", front->begin());
}
}
@ -262,8 +252,7 @@ void insertBB(Edge ed,
Instruction *rInst,
Instruction *countInst,
int numPaths, int Methno){
static int i=-1;
i++;
BasicBlock* BB1=ed.getFirst()->getElement();
BasicBlock* BB2=ed.getSecond()->getElement();
@ -274,21 +263,13 @@ void insertBB(Edge ed,
cerr<<"########################\n";
#endif
char counterstr[100];
sprintf(counterstr,"counter%d",i);
std::string ctr=counterstr;
//We need to insert a BB between BB1 and BB2
TerminatorInst *TI=BB1->getTerminator();
BasicBlock *newBB=new BasicBlock(ctr, BB1->getParent());
BasicBlock *newBB=new BasicBlock("counter", BB1->getParent());
//Is terminator a branch instruction?
//then we need to change branch destinations to include new BB
//std::cerr<<"before cast!\n";
//std::cerr<<"Method no in Edgecode:"<<Methno<<"\n";
//std::cerr<<"Instruction\n";
//std::cerr<<*TI;
BranchInst *BI = cast<BranchInst>(TI);
if(BI->isUnconditional()){
@ -310,10 +291,8 @@ void insertBB(Edge ed,
//get code for the new BB
edgeCode->getCode(rInst, countInst, BB1->getParent(), newBB, numPaths, Methno);
//std::cerr<<"After casting\n";
//get code for the new BB
//now iterate over BB2, and set its Phi nodes right
//now iterate over BB2, and set its Phi nodes right
for(BasicBlock::iterator BB2Inst = BB2->begin(), BBend = BB2->end();
BB2Inst != BBend; ++BB2Inst){

106
lib/Transforms/Instrumentation/ProfilePaths/Graph.cpp
View File

@ -52,30 +52,75 @@ Graph::Graph(std::vector<Node*> n, std::vector<Edge> e,
}
//sorting edgelist, called by backEdgeVist ONLY!!!
Graph::nodeList &Graph::sortNodeList(Node *par, nodeList &nl){
Graph::nodeList &Graph::sortNodeList(Node *par, nodeList &nl, vector<Edge> &be){
assert(par && "null node pointer");
BasicBlock *bbPar = par->getElement();
if(nl.size()<=1) return nl;
if(getExit() == par) return nl;
for(nodeList::iterator NLI = nl.begin(), NLE = nl.end()-1; NLI != NLE; ++NLI){
nodeList::iterator min = NLI;
for(nodeList::iterator LI = NLI+1, LE = nl.end(); LI!=LE; ++LI){
//if LI < min, min = LI
if(min->element->getElement() == LI->element->getElement())
continue;
if(min->element->getElement() == LI->element->getElement() &&
min->element == getExit()){
TerminatorInst *tti = par->getElement()->getTerminator();
BranchInst *ti = cast<BranchInst>(tti);
assert(ti && "not a branch");
assert(ti->getNumSuccessors()==2 && "less successors!");
//same successors: so might be exit???
//if it is exit, then see which is backedge
//check if LI is a left back edge!
TerminatorInst *tti = par->getElement()->getTerminator();
BranchInst *ti = cast<BranchInst>(tti);
assert(ti && "not a branch");
assert(ti->getNumSuccessors()==2 && "less successors!");
BasicBlock *tB = ti->getSuccessor(0);
BasicBlock *fB = ti->getSuccessor(1);
//so one of LI or min must be back edge!
//Algo: if succ(0)!=LI (and so !=min) then succ(0) is backedge
//and then see which of min or LI is backedge
//THEN if LI is in be, then min=LI
if(LI->element->getElement() != tB){//so backedge must be made min!
for(vector<Edge>::iterator VBEI = be.begin(), VBEE = be.end();
VBEI != VBEE; ++VBEI){
if(VBEI->getRandId() == LI->randId){
min = LI;
break;
}
else if(VBEI->getRandId() == min->randId)
break;
}
}
else{// if(LI->element->getElement() != fB)
for(vector<Edge>::iterator VBEI = be.begin(), VBEE = be.end();
VBEI != VBEE; ++VBEI){
if(VBEI->getRandId() == min->randId){
min = LI;
break;
}
else if(VBEI->getRandId() == LI->randId)
break;
}
}
}
BasicBlock *tB = ti->getSuccessor(0);
BasicBlock *fB = ti->getSuccessor(1);
if(tB == LI->element->getElement() || fB == min->element->getElement())
min = LI;
else if (min->element->getElement() != LI->element->getElement()){
TerminatorInst *tti = par->getElement()->getTerminator();
BranchInst *ti = cast<BranchInst>(tti);
assert(ti && "not a branch");
if(ti->getNumSuccessors()<=1) continue;
assert(ti->getNumSuccessors()==2 && "less successors!");
BasicBlock *tB = ti->getSuccessor(0);
BasicBlock *fB = ti->getSuccessor(1);
if(tB == LI->element->getElement() || fB == min->element->getElement())
min = LI;
}
}
graphListElement tmpElmnt = *min;
@ -416,12 +461,6 @@ vector<Node *> Graph::reverseTopologicalSort(){
DFS_Visit(*LI, toReturn);
}
//print nodes
//std::cerr<<"Topological sort--------\n";
//for(vector<Node *>::iterator VI = toReturn.begin(), VE = toReturn.end();
// VI!=VE; ++VI)
//std::cerr<<(*VI)->getElement()->getName()<<"->";
//std::cerr<<"\n----------------------\n";
return toReturn;
}
@ -487,15 +526,9 @@ void Graph::reverseWts(){
//a node with smaller time, and GREY color
void Graph::getBackEdges(vector<Edge > &be, map<Node *, int> &d){
map<Node *, Color > color;
//map<Node *, int > d;
//vector<Node *> allNodes=getAllNodes();
int time=0;
//for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end();
// NI!=NE; ++NI){
//if(color[*NI]!=GREY && color[*NI]!=BLACK)
//printGraph();
getBackEdgesVisit(getRoot(), be, color, d, time);//*NI, be, color, d, time);
//}
getBackEdgesVisit(getRoot(), be, color, d, time);
}
//helper function to get back edges: it is called by
@ -507,25 +540,14 @@ void Graph::getBackEdgesVisit(Node *u, vector<Edge > &be,
time++;
d[u]=time;
//std::cerr<<"Node list-----\n";
vector<graphListElement> succ_list = getSortedNodeList(u);
//for(vector<graphListElement>::iterator vl=succ_list.begin(),
// ve=succ_list.end(); vl!=ve; ++vl){
//Node *v=vl->element;
//std::cerr<<v->getElement()->getName()<<"->";
//}
//std::cerr<<"\n-------- end Node list\n";
vector<graphListElement> &succ_list = getNodeList(u);
for(vector<graphListElement>::iterator vl=succ_list.begin(),
ve=succ_list.end(); vl!=ve; ++vl){
Node *v=vl->element;
// for(vector<Node *>::const_iterator v=succ_list.begin(), ve=succ_list.end();
// v!=ve; ++v){
if(color[v]!=GREY && color[v]!=BLACK){
getBackEdgesVisit(v, be, color, d, time);
}
if(color[v]!=GREY && color[v]!=BLACK){
getBackEdgesVisit(v, be, color, d, time);
}
//now checking for d and f vals
if(color[v]==GREY){

23
lib/Transforms/Instrumentation/ProfilePaths/Graph.h
View File

@ -149,7 +149,8 @@ struct NodeListSort{
return name1<name2;
}
};
struct EdgeCompare{
struct EdgeCompare2{
bool operator()(Edge e1, Edge e2) const {
assert(!e1.isNull() && !e2.isNull());
Node *x1=e1.getFirst();
@ -158,10 +159,19 @@ struct EdgeCompare{
Node *y2=e2.getSecond();
int w1=e1.getWeight();
int w2=e2.getWeight();
return (*x1<*y1 || (*x1==*y1 && *x2<*y2) || (*x1==*y1 && *x2==*y2 && w1<w2));
double r1 = e1.getRandId();
double r2 = e2.getRandId();
//return (*x1<*y1 || (*x1==*y1 && *x2<*y2) || (*x1==*y1 && *x2==*y2 && w1<w2));
return (*x1<*y1 || (*x1==*y1 && *x2<*y2) || (*x1==*y1 && *x2==*y2 && w1<w2) || (*x1==*y1 && *x2==*y2 && w1==w2 && r1<r2));
}
};
//struct EdgeCompare2{
//bool operator()(Edge e1, Edge e2) const {
// assert(!e1.isNull() && !e2.isNull());
// return (e1.getRandId()<e2.getRandId());
//}
//};
//this is used to color vertices
@ -309,7 +319,7 @@ public:
//get a vector of back edges in the graph
void getBackEdges(std::vector<Edge> &be, std::map<Node *, int> &d);
nodeList &sortNodeList(Node *par, nodeList &nl);
nodeList &sortNodeList(Node *par, nodeList &nl, std::vector<Edge> &be);
//Get the Maximal spanning tree (also a graph)
//of the graph
@ -324,10 +334,10 @@ public:
return nodes[nd];//sortNodeList(nd, nli->second);
}
nodeList &getSortedNodeList(Node *nd) {
nodeList &getSortedNodeList(Node *nd, std::vector<Edge> &be) {
elementIterator nli = nodes.find(nd);
assert(nli != nodes.end() && "Node must be in nodes map");
return sortNodeList(nd, nodes[nd]);
return sortNodeList(nd, nodes[nd], be);
}
//get the root of the graph
@ -450,7 +460,8 @@ void addDummyEdges(std::vector<Edge> &stDummy, std::vector<Edge> &exDummy, Graph
//such that if we traverse along any path from root to exit, and
//add up the edge values, we get a path number that uniquely
//refers to the path we travelled
int valueAssignmentToEdges(Graph& g, std::map<Node *, int> nodePriority);
int valueAssignmentToEdges(Graph& g, std::map<Node *, int> nodePriority,
std::vector<Edge> &be);
void getBBtrace(std::vector<BasicBlock *> &vBB, int pathNo, Function *M);
#endif

133
lib/Transforms/Instrumentation/ProfilePaths/GraphAuxiliary.cpp
View File

@ -7,15 +7,18 @@
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
#include "llvm/Transforms/Instrumentation/Graph.h"
#include "llvm/Function.h"
#include "llvm/Pass.h"
#include "llvm/Module.h"
#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/InstrTypes.h"
#include "llvm/Transforms/Instrumentation/Graph.h"
#include "llvm/iTerminators.h"
#include <algorithm>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
//using std::list;
@ -69,7 +72,8 @@ static void removeTreeEdges(Graph &g, Graph& t){
//such that if we traverse along any path from root to exit, and
//add up the edge values, we get a path number that uniquely
//refers to the path we travelled
int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority,
vector<Edge> &be){
vector<Node *> revtop=g.reverseTopologicalSort();
map<Node *,int > NumPaths;
for(vector<Node *>::iterator RI=revtop.begin(), RE=revtop.end();
@ -79,7 +83,9 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
else{
NumPaths[*RI]=0;
Graph::nodeList &nlist=g.getNodeList(*RI);
// Modified Graph::nodeList &nlist=g.getNodeList(*RI);
Graph::nodeList &nlist=g.getSortedNodeList(*RI, be);
//sort nodelist by increasing order of numpaths
int sz=nlist.size();
@ -104,7 +110,7 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
else{
TerminatorInst *tti = (*RI)->getElement()->getTerminator();
//std::cerr<<*tti<<std::endl;
BranchInst *ti = cast<BranchInst>(tti);
assert(ti && "not a branch");
assert(ti->getNumSuccessors()==2 && "less successors!");
@ -123,14 +129,11 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
}
//sorted now!
//std::cerr<<"Considering Order-----\n";
for(Graph::nodeList::iterator GLI=nlist.begin(), GLE=nlist.end();
GLI!=GLE; ++GLI){
//std::cerr<<GLI->element->getElement()->getName()<<"->";
GLI->weight=NumPaths[*RI];
GLI->weight=NumPaths[*RI];
NumPaths[*RI]+=NumPaths[GLI->element];
}
//std::cerr<<"\nend order $$$$$$$$$$$$$$$$$$$$$$$$\n";
}
}
return NumPaths[g.getRoot()];
@ -165,7 +168,7 @@ static int inc_Dir(Edge e, Edge f){
//used for getting edge increments (read comments above in inc_Dir)
//inc_DFS is a modification of DFS
static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare>& Increment,
static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment,
int events, Node *v, Edge e){
vector<Node *> allNodes=t.getAllNodes();
@ -219,15 +222,17 @@ static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare>& Increment,
//and assign them some values such that
//if we consider just this subset, it still represents
//the path sum along any path in the graph
static map<Edge, int, EdgeCompare> getEdgeIncrements(Graph& g, Graph& t){
static map<Edge, int, EdgeCompare2> getEdgeIncrements(Graph& g, Graph& t,
vector<Edge> &be){
//get all edges in g-t
map<Edge, int, EdgeCompare> Increment;
map<Edge, int, EdgeCompare2> Increment;
vector<Node *> allNodes=g.getAllNodes();
for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE;
++NI){
Graph::nodeList node_list=g.getNodeList(*NI);
Graph::nodeList node_list=g.getSortedNodeList(*NI, be);
//modified g.getNodeList(*NI);
for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end();
NLI!=NLE; ++NLI){
Edge ed(*NI, NLI->element,NLI->weight,NLI->randId);
@ -242,7 +247,8 @@ static map<Edge, int, EdgeCompare> getEdgeIncrements(Graph& g, Graph& t){
for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE;
++NI){
Graph::nodeList node_list=g.getNodeList(*NI);
Graph::nodeList node_list=g.getSortedNodeList(*NI, be);
//modified g.getNodeList(*NI);
for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end();
NLI!=NLE; ++NLI){
Edge ed(*NI, NLI->element,NLI->weight, NLI->randId);
@ -267,9 +273,9 @@ graphListElement *findNodeInList(Graph::nodeList &NL, Node *N);
//the kind of code to be inserted along an edge
//The idea here is to minimize the computation
//by inserting only the needed code
static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &instr,
static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> &instr,
vector<Edge > &chords,
map<Edge,int, EdgeCompare> &edIncrements){
map<Edge,int, EdgeCompare2> &edIncrements){
//Register initialization code
vector<Node *> ws;
@ -302,14 +308,12 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &i
}
else if(g.getNumberOfIncomingEdges(w)==1){
ws.push_back(w);
//std::cerr<<"Added w\n";
}
else{
getEdgeCode *edCd=new getEdgeCode();
edCd->setCond(2);
edCd->setInc(0);
instr[ed]=edCd;
//std::cerr<<"Case 2\n";
}
}
}
@ -328,39 +332,42 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &i
for(vector<Node *>::iterator EII=lllt.begin(); EII!=lllt.end() ;++EII){
Node *lnode=*EII;
Graph::nodeList &nl = g.getNodeList(lnode);
graphListElement *N = findNodeInList(nl, w);
if (N){
Node *v=lnode;
//if chords has v->w
Edge ed(v,w, N->weight, N->randId);
getEdgeCode *edCd=new getEdgeCode();
bool hasEdge=false;
for(vector<Edge>::iterator CI=chords.begin(), CE=chords.end(); CI!=CE;
++CI){
if(*CI==ed && CI->getWeight()==N->weight){
hasEdge=true;
break;
}
}
if(hasEdge){
char str[100];
if(instr[ed]!=NULL && instr[ed]->getCond()==1){
instr[ed]->setCond(4);
}
else{
edCd->setCond(5);
edCd->setInc(edIncrements[ed]);
instr[ed]=edCd;
}
}
else if(g.getNumberOfOutgoingEdges(v)==1)
ws.push_back(v);
else{
edCd->setCond(6);
instr[ed]=edCd;
}
//graphListElement *N = findNodeInList(nl, w);
for(Graph::nodeList::const_iterator N = nl.begin(),
NNEN = nl.end(); N!= NNEN; ++N){
if (*N->element == *w){
Node *v=lnode;
//if chords has v->w
Edge ed(v,w, N->weight, N->randId);
getEdgeCode *edCd=new getEdgeCode();
bool hasEdge=false;
for(vector<Edge>::iterator CI=chords.begin(), CE=chords.end(); CI!=CE;
++CI){
if(*CI==ed && CI->getWeight()==N->weight){
hasEdge=true;
break;
}
}
if(hasEdge){
//char str[100];
if(instr[ed]!=NULL && instr[ed]->getCond()==1){
instr[ed]->setCond(4);
}
else{
edCd->setCond(5);
edCd->setInc(edIncrements[ed]);
instr[ed]=edCd;
}
}
else if(g.getNumberOfOutgoingEdges(v)==1)
ws.push_back(v);
else{
edCd->setCond(6);
instr[ed]=edCd;
}
}
}
}
}
@ -416,14 +423,14 @@ void printEdge(Edge ed){
static void moveDummyCode(vector<Edge> &stDummy,
vector<Edge> &exDummy,
vector<Edge> &be,
map<Edge, getEdgeCode *, EdgeCompare> &insertions,
map<Edge, getEdgeCode *, EdgeCompare2> &insertions,
Graph &g){
typedef vector<Edge >::iterator vec_iter;
map<Edge,getEdgeCode *, EdgeCompare> temp;
map<Edge,getEdgeCode *, EdgeCompare2> temp;
//iterate over edges with code
std::vector<Edge> toErase;
for(map<Edge,getEdgeCode *, EdgeCompare>::iterator MI=insertions.begin(),
for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=insertions.begin(),
ME=insertions.end(); MI!=ME; ++MI){
Edge ed=MI->first;
getEdgeCode *edCd=MI->second;
@ -462,7 +469,7 @@ static void moveDummyCode(vector<Edge> &stDummy,
g.removeEdgeWithWt(*vmi);
}
for(map<Edge,getEdgeCode *, EdgeCompare>::iterator MI=temp.begin(),
for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=temp.begin(),
ME=temp.end(); MI!=ME; ++MI){
insertions[MI->first]=MI->second;
}
@ -584,15 +591,15 @@ void processGraph(Graph &g,
//if we consider just this subset, it still represents
//the path sum along any path in the graph
map<Edge, int, EdgeCompare> increment=getEdgeIncrements(g,*t);
map<Edge, int, EdgeCompare2> increment=getEdgeIncrements(g,*t, be);
#ifdef DEBUG_PATH_PROFILES
//print edge increments for debugging
for(map<Edge, int, EdgeCompare>::iterator M_I=increment.begin(), M_E=increment.end();
M_I!=M_E; ++M_I){
printEdge(M_I->first);
cerr<<"Increment for above:"<<M_I->second<<"\n";
std::cerr<<"Edge Increments------\n";
for(map<Edge, int, EdgeCompare2>::iterator MMI=increment.begin(), MME=increment.end(); MMI != MME; ++MMI){
printEdge(MMI->first);
std::cerr<<"Increment for above:"<<MMI->second<<"\n";
}
std::cerr<<"-------end of edge increments\n";
#endif
@ -606,15 +613,13 @@ void processGraph(Graph &g,
getChords(chords, g, *t);
//cerr<<"Graph before getCodeInsertion:\n";
//printGraph(g);
map<Edge, getEdgeCode *, EdgeCompare> codeInsertions;
map<Edge, getEdgeCode *, EdgeCompare2> codeInsertions;
getCodeInsertions(g, codeInsertions, chords,increment);
#ifdef DEBUG_PATH_PROFILES
//print edges with code for debugging
cerr<<"Code inserted in following---------------\n";
for(map<Edge, getEdgeCode *>::iterator cd_i=codeInsertions.begin(),
for(map<Edge, getEdgeCode *, EdgeCompare2>::iterator cd_i=codeInsertions.begin(),
cd_e=codeInsertions.end(); cd_i!=cd_e; ++cd_i){
printEdge(cd_i->first);
cerr<<cd_i->second->getCond()<<":"<<cd_i->second->getInc()<<"\n";

133
lib/Transforms/Instrumentation/ProfilePaths/GraphAuxillary.cpp
View File

@ -7,15 +7,18 @@
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Utils/UnifyFunctionExitNodes.h"
#include "llvm/Transforms/Instrumentation/Graph.h"
#include "llvm/Function.h"
#include "llvm/Pass.h"
#include "llvm/Module.h"
#include "llvm/Function.h"
#include "llvm/BasicBlock.h"
#include "llvm/InstrTypes.h"
#include "llvm/Transforms/Instrumentation/Graph.h"
#include "llvm/iTerminators.h"
#include <algorithm>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
//using std::list;
@ -69,7 +72,8 @@ static void removeTreeEdges(Graph &g, Graph& t){
//such that if we traverse along any path from root to exit, and
//add up the edge values, we get a path number that uniquely
//refers to the path we travelled
int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority,
vector<Edge> &be){
vector<Node *> revtop=g.reverseTopologicalSort();
map<Node *,int > NumPaths;
for(vector<Node *>::iterator RI=revtop.begin(), RE=revtop.end();
@ -79,7 +83,9 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
else{
NumPaths[*RI]=0;
Graph::nodeList &nlist=g.getNodeList(*RI);
// Modified Graph::nodeList &nlist=g.getNodeList(*RI);
Graph::nodeList &nlist=g.getSortedNodeList(*RI, be);
//sort nodelist by increasing order of numpaths
int sz=nlist.size();
@ -104,7 +110,7 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
else{
TerminatorInst *tti = (*RI)->getElement()->getTerminator();
//std::cerr<<*tti<<std::endl;
BranchInst *ti = cast<BranchInst>(tti);
assert(ti && "not a branch");
assert(ti->getNumSuccessors()==2 && "less successors!");
@ -123,14 +129,11 @@ int valueAssignmentToEdges(Graph& g, map<Node *, int> nodePriority){
}
//sorted now!
//std::cerr<<"Considering Order-----\n";
for(Graph::nodeList::iterator GLI=nlist.begin(), GLE=nlist.end();
GLI!=GLE; ++GLI){
//std::cerr<<GLI->element->getElement()->getName()<<"->";
GLI->weight=NumPaths[*RI];
GLI->weight=NumPaths[*RI];
NumPaths[*RI]+=NumPaths[GLI->element];
}
//std::cerr<<"\nend order $$$$$$$$$$$$$$$$$$$$$$$$\n";
}
}
return NumPaths[g.getRoot()];
@ -165,7 +168,7 @@ static int inc_Dir(Edge e, Edge f){
//used for getting edge increments (read comments above in inc_Dir)
//inc_DFS is a modification of DFS
static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare>& Increment,
static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare2>& Increment,
int events, Node *v, Edge e){
vector<Node *> allNodes=t.getAllNodes();
@ -219,15 +222,17 @@ static void inc_DFS(Graph& g,Graph& t,map<Edge, int, EdgeCompare>& Increment,
//and assign them some values such that
//if we consider just this subset, it still represents
//the path sum along any path in the graph
static map<Edge, int, EdgeCompare> getEdgeIncrements(Graph& g, Graph& t){
static map<Edge, int, EdgeCompare2> getEdgeIncrements(Graph& g, Graph& t,
vector<Edge> &be){
//get all edges in g-t
map<Edge, int, EdgeCompare> Increment;
map<Edge, int, EdgeCompare2> Increment;
vector<Node *> allNodes=g.getAllNodes();
for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE;
++NI){
Graph::nodeList node_list=g.getNodeList(*NI);
Graph::nodeList node_list=g.getSortedNodeList(*NI, be);
//modified g.getNodeList(*NI);
for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end();
NLI!=NLE; ++NLI){
Edge ed(*NI, NLI->element,NLI->weight,NLI->randId);
@ -242,7 +247,8 @@ static map<Edge, int, EdgeCompare> getEdgeIncrements(Graph& g, Graph& t){
for(vector<Node *>::iterator NI=allNodes.begin(), NE=allNodes.end(); NI!=NE;
++NI){
Graph::nodeList node_list=g.getNodeList(*NI);
Graph::nodeList node_list=g.getSortedNodeList(*NI, be);
//modified g.getNodeList(*NI);
for(Graph::nodeList::iterator NLI=node_list.begin(), NLE=node_list.end();
NLI!=NLE; ++NLI){
Edge ed(*NI, NLI->element,NLI->weight, NLI->randId);
@ -267,9 +273,9 @@ graphListElement *findNodeInList(Graph::nodeList &NL, Node *N);
//the kind of code to be inserted along an edge
//The idea here is to minimize the computation
//by inserting only the needed code
static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &instr,
static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare2> &instr,
vector<Edge > &chords,
map<Edge,int, EdgeCompare> &edIncrements){
map<Edge,int, EdgeCompare2> &edIncrements){
//Register initialization code
vector<Node *> ws;
@ -302,14 +308,12 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &i
}
else if(g.getNumberOfIncomingEdges(w)==1){
ws.push_back(w);
//std::cerr<<"Added w\n";
}
else{
getEdgeCode *edCd=new getEdgeCode();
edCd->setCond(2);
edCd->setInc(0);
instr[ed]=edCd;
//std::cerr<<"Case 2\n";
}
}
}
@ -328,39 +332,42 @@ static void getCodeInsertions(Graph &g, map<Edge, getEdgeCode *, EdgeCompare> &i
for(vector<Node *>::iterator EII=lllt.begin(); EII!=lllt.end() ;++EII){
Node *lnode=*EII;
Graph::nodeList &nl = g.getNodeList(lnode);
graphListElement *N = findNodeInList(nl, w);
if (N){
Node *v=lnode;
//if chords has v->w
Edge ed(v,w, N->weight, N->randId);
getEdgeCode *edCd=new getEdgeCode();
bool hasEdge=false;
for(vector<Edge>::iterator CI=chords.begin(), CE=chords.end(); CI!=CE;
++CI){
if(*CI==ed && CI->getWeight()==N->weight){
hasEdge=true;
break;
}
}
if(hasEdge){
char str[100];
if(instr[ed]!=NULL && instr[ed]->getCond()==1){
instr[ed]->setCond(4);
}
else{
edCd->setCond(5);
edCd->setInc(edIncrements[ed]);
instr[ed]=edCd;
}
}
else if(g.getNumberOfOutgoingEdges(v)==1)
ws.push_back(v);
else{
edCd->setCond(6);
instr[ed]=edCd;
}
//graphListElement *N = findNodeInList(nl, w);
for(Graph::nodeList::const_iterator N = nl.begin(),
NNEN = nl.end(); N!= NNEN; ++N){
if (*N->element == *w){
Node *v=lnode;
//if chords has v->w
Edge ed(v,w, N->weight, N->randId);
getEdgeCode *edCd=new getEdgeCode();
bool hasEdge=false;
for(vector<Edge>::iterator CI=chords.begin(), CE=chords.end(); CI!=CE;
++CI){
if(*CI==ed && CI->getWeight()==N->weight){
hasEdge=true;
break;
}
}
if(hasEdge){
//char str[100];
if(instr[ed]!=NULL && instr[ed]->getCond()==1){
instr[ed]->setCond(4);
}
else{
edCd->setCond(5);
edCd->setInc(edIncrements[ed]);
instr[ed]=edCd;
}
}
else if(g.getNumberOfOutgoingEdges(v)==1)
ws.push_back(v);
else{
edCd->setCond(6);
instr[ed]=edCd;
}
}
}
}
}
@ -416,14 +423,14 @@ void printEdge(Edge ed){
static void moveDummyCode(vector<Edge> &stDummy,
vector<Edge> &exDummy,
vector<Edge> &be,
map<Edge, getEdgeCode *, EdgeCompare> &insertions,
map<Edge, getEdgeCode *, EdgeCompare2> &insertions,
Graph &g){
typedef vector<Edge >::iterator vec_iter;
map<Edge,getEdgeCode *, EdgeCompare> temp;
map<Edge,getEdgeCode *, EdgeCompare2> temp;
//iterate over edges with code
std::vector<Edge> toErase;
for(map<Edge,getEdgeCode *, EdgeCompare>::iterator MI=insertions.begin(),
for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=insertions.begin(),
ME=insertions.end(); MI!=ME; ++MI){
Edge ed=MI->first;
getEdgeCode *edCd=MI->second;
@ -462,7 +469,7 @@ static void moveDummyCode(vector<Edge> &stDummy,
g.removeEdgeWithWt(*vmi);
}
for(map<Edge,getEdgeCode *, EdgeCompare>::iterator MI=temp.begin(),
for(map<Edge,getEdgeCode *, EdgeCompare2>::iterator MI=temp.begin(),
ME=temp.end(); MI!=ME; ++MI){
insertions[MI->first]=MI->second;
}
@ -584,15 +591,15 @@ void processGraph(Graph &g,
//if we consider just this subset, it still represents
//the path sum along any path in the graph
map<Edge, int, EdgeCompare> increment=getEdgeIncrements(g,*t);
map<Edge, int, EdgeCompare2> increment=getEdgeIncrements(g,*t, be);
#ifdef DEBUG_PATH_PROFILES
//print edge increments for debugging
for(map<Edge, int, EdgeCompare>::iterator M_I=increment.begin(), M_E=increment.end();
M_I!=M_E; ++M_I){
printEdge(M_I->first);
cerr<<"Increment for above:"<<M_I->second<<"\n";
std::cerr<<"Edge Increments------\n";
for(map<Edge, int, EdgeCompare2>::iterator MMI=increment.begin(), MME=increment.end(); MMI != MME; ++MMI){
printEdge(MMI->first);
std::cerr<<"Increment for above:"<<MMI->second<<"\n";
}
std::cerr<<"-------end of edge increments\n";
#endif
@ -606,15 +613,13 @@ void processGraph(Graph &g,
getChords(chords, g, *t);
//cerr<<"Graph before getCodeInsertion:\n";
//printGraph(g);
map<Edge, getEdgeCode *, EdgeCompare> codeInsertions;
map<Edge, getEdgeCode *, EdgeCompare2> codeInsertions;
getCodeInsertions(g, codeInsertions, chords,increment);
#ifdef DEBUG_PATH_PROFILES
//print edges with code for debugging
cerr<<"Code inserted in following---------------\n";
for(map<Edge, getEdgeCode *>::iterator cd_i=codeInsertions.begin(),
for(map<Edge, getEdgeCode *, EdgeCompare2>::iterator cd_i=codeInsertions.begin(),
cd_e=codeInsertions.end(); cd_i!=cd_e; ++cd_i){
printEdge(cd_i->first);
cerr<<cd_i->second->getCond()<<":"<<cd_i->second->getInc()<<"\n";