1 //===- ProfileInfoLoaderPass.cpp - LLVM Pass to load profile info ---------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements a concrete implementation of profiling information that 11 // loads the information from a profile dump file. 12 // 13 //===----------------------------------------------------------------------===// 14 #define DEBUG_TYPE "profile-loader" 15 #include "llvm/BasicBlock.h" 16 #include "llvm/InstrTypes.h" 17 #include "llvm/Module.h" 18 #include "llvm/Pass.h" 19 #include "llvm/Analysis/Passes.h" 20 #include "llvm/Analysis/ProfileInfo.h" 21 #include "llvm/Analysis/ProfileInfoLoader.h" 22 #include "llvm/Support/CommandLine.h" 23 #include "llvm/Support/CFG.h" 24 #include "llvm/Support/Debug.h" 25 #include "llvm/Support/raw_ostream.h" 26 #include "llvm/Support/Format.h" 27 #include "llvm/ADT/Statistic.h" 28 #include "llvm/ADT/SmallSet.h" 29 #include <set> 30 using namespace llvm; 31 32 STATISTIC(NumEdgesRead, "The # of edges read."); 33 34 static cl::opt<std::string> 35 ProfileInfoFilename("profile-info-file", cl::init("llvmprof.out"), 36 cl::value_desc("filename"), 37 cl::desc("Profile file loaded by -profile-loader")); 38 39 namespace { 40 class LoaderPass : public ModulePass, public ProfileInfo { 41 std::string Filename; 42 std::set<Edge> SpanningTree; 43 std::set<const BasicBlock*> BBisUnvisited; 44 unsigned ReadCount; 45 public: 46 static char ID; // Class identification, replacement for typeinfo 47 explicit LoaderPass(const std::string &filename = "") 48 : ModulePass(ID), Filename(filename) { 49 initializeLoaderPassPass(*PassRegistry::getPassRegistry()); 50 if (filename.empty()) Filename = ProfileInfoFilename; 51 } 52 53 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 54 AU.setPreservesAll(); 55 } 56 57 virtual const char *getPassName() const { 58 return "Profiling information loader"; 59 } 60 61 // recurseBasicBlock() - Calculates the edge weights for as much basic 62 // blocks as possbile. 63 virtual void recurseBasicBlock(const BasicBlock *BB); 64 virtual void readEdgeOrRemember(Edge, Edge&, unsigned &, double &); 65 virtual void readEdge(ProfileInfo::Edge, std::vector<unsigned>&); 66 67 /// getAdjustedAnalysisPointer - This method is used when a pass implements 68 /// an analysis interface through multiple inheritance. If needed, it 69 /// should override this to adjust the this pointer as needed for the 70 /// specified pass info. 71 virtual void *getAdjustedAnalysisPointer(AnalysisID PI) { 72 if (PI == &ProfileInfo::ID) 73 return (ProfileInfo*)this; 74 return this; 75 } 76 77 /// run - Load the profile information from the specified file. 78 virtual bool runOnModule(Module &M); 79 }; 80 } // End of anonymous namespace 81 82 char LoaderPass::ID = 0; 83 INITIALIZE_AG_PASS(LoaderPass, ProfileInfo, "profile-loader", 84 "Load profile information from llvmprof.out", false, true, false) 85 86 char &llvm::ProfileLoaderPassID = LoaderPass::ID; 87 88 ModulePass *llvm::createProfileLoaderPass() { return new LoaderPass(); } 89 90 /// createProfileLoaderPass - This function returns a Pass that loads the 91 /// profiling information for the module from the specified filename, making it 92 /// available to the optimizers. 93 Pass *llvm::createProfileLoaderPass(const std::string &Filename) { 94 return new LoaderPass(Filename); 95 } 96 97 void LoaderPass::readEdgeOrRemember(Edge edge, Edge &tocalc, 98 unsigned &uncalc, double &count) { 99 double w; 100 if ((w = getEdgeWeight(edge)) == MissingValue) { 101 tocalc = edge; 102 uncalc++; 103 } else { 104 count+=w; 105 } 106 } 107 108 // recurseBasicBlock - Visits all neighbours of a block and then tries to 109 // calculate the missing edge values. 110 void LoaderPass::recurseBasicBlock(const BasicBlock *BB) { 111 112 // break recursion if already visited 113 if (BBisUnvisited.find(BB) == BBisUnvisited.end()) return; 114 BBisUnvisited.erase(BB); 115 if (!BB) return; 116 117 for (succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB); 118 bbi != bbe; ++bbi) { 119 recurseBasicBlock(*bbi); 120 } 121 for (const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB); 122 bbi != bbe; ++bbi) { 123 recurseBasicBlock(*bbi); 124 } 125 126 Edge tocalc; 127 if (CalculateMissingEdge(BB, tocalc)) { 128 SpanningTree.erase(tocalc); 129 } 130 } 131 132 void LoaderPass::readEdge(ProfileInfo::Edge e, 133 std::vector<unsigned> &ECs) { 134 if (ReadCount < ECs.size()) { 135 double weight = ECs[ReadCount++]; 136 if (weight != ProfileInfoLoader::Uncounted) { 137 // Here the data realm changes from the unsigned of the file to the 138 // double of the ProfileInfo. This conversion is save because we know 139 // that everything thats representable in unsinged is also representable 140 // in double. 141 EdgeInformation[getFunction(e)][e] += (double)weight; 142 143 DEBUG(dbgs() << "--Read Edge Counter for " << e 144 << " (# "<< (ReadCount-1) << "): " 145 << (unsigned)getEdgeWeight(e) << "\n"); 146 } else { 147 // This happens only if reading optimal profiling information, not when 148 // reading regular profiling information. 149 SpanningTree.insert(e); 150 } 151 } 152 } 153 154 bool LoaderPass::runOnModule(Module &M) { 155 ProfileInfoLoader PIL("profile-loader", Filename, M); 156 157 EdgeInformation.clear(); 158 std::vector<unsigned> Counters = PIL.getRawEdgeCounts(); 159 if (Counters.size() > 0) { 160 ReadCount = 0; 161 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) { 162 if (F->isDeclaration()) continue; 163 DEBUG(dbgs()<<"Working on "<<F->getNameStr()<<"\n"); 164 readEdge(getEdge(0,&F->getEntryBlock()), Counters); 165 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { 166 TerminatorInst *TI = BB->getTerminator(); 167 for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) { 168 readEdge(getEdge(BB,TI->getSuccessor(s)), Counters); 169 } 170 } 171 } 172 if (ReadCount != Counters.size()) { 173 errs() << "WARNING: profile information is inconsistent with " 174 << "the current program!\n"; 175 } 176 NumEdgesRead = ReadCount; 177 } 178 179 Counters = PIL.getRawOptimalEdgeCounts(); 180 if (Counters.size() > 0) { 181 ReadCount = 0; 182 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) { 183 if (F->isDeclaration()) continue; 184 DEBUG(dbgs()<<"Working on "<<F->getNameStr()<<"\n"); 185 readEdge(getEdge(0,&F->getEntryBlock()), Counters); 186 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) { 187 TerminatorInst *TI = BB->getTerminator(); 188 if (TI->getNumSuccessors() == 0) { 189 readEdge(getEdge(BB,0), Counters); 190 } 191 for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) { 192 readEdge(getEdge(BB,TI->getSuccessor(s)), Counters); 193 } 194 } 195 while (SpanningTree.size() > 0) { 196 197 unsigned size = SpanningTree.size(); 198 199 BBisUnvisited.clear(); 200 for (std::set<Edge>::iterator ei = SpanningTree.begin(), 201 ee = SpanningTree.end(); ei != ee; ++ei) { 202 BBisUnvisited.insert(ei->first); 203 BBisUnvisited.insert(ei->second); 204 } 205 while (BBisUnvisited.size() > 0) { 206 recurseBasicBlock(*BBisUnvisited.begin()); 207 } 208 209 if (SpanningTree.size() == size) { 210 DEBUG(dbgs()<<"{"); 211 for (std::set<Edge>::iterator ei = SpanningTree.begin(), 212 ee = SpanningTree.end(); ei != ee; ++ei) { 213 DEBUG(dbgs()<< *ei <<","); 214 } 215 assert(0 && "No edge calculated!"); 216 } 217 218 } 219 } 220 if (ReadCount != Counters.size()) { 221 errs() << "WARNING: profile information is inconsistent with " 222 << "the current program!\n"; 223 } 224 NumEdgesRead = ReadCount; 225 } 226 227 BlockInformation.clear(); 228 Counters = PIL.getRawBlockCounts(); 229 if (Counters.size() > 0) { 230 ReadCount = 0; 231 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) { 232 if (F->isDeclaration()) continue; 233 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) 234 if (ReadCount < Counters.size()) 235 // Here the data realm changes from the unsigned of the file to the 236 // double of the ProfileInfo. This conversion is save because we know 237 // that everything thats representable in unsinged is also 238 // representable in double. 239 BlockInformation[F][BB] = (double)Counters[ReadCount++]; 240 } 241 if (ReadCount != Counters.size()) { 242 errs() << "WARNING: profile information is inconsistent with " 243 << "the current program!\n"; 244 } 245 } 246 247 FunctionInformation.clear(); 248 Counters = PIL.getRawFunctionCounts(); 249 if (Counters.size() > 0) { 250 ReadCount = 0; 251 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) { 252 if (F->isDeclaration()) continue; 253 if (ReadCount < Counters.size()) 254 // Here the data realm changes from the unsigned of the file to the 255 // double of the ProfileInfo. This conversion is save because we know 256 // that everything thats representable in unsinged is also 257 // representable in double. 258 FunctionInformation[F] = (double)Counters[ReadCount++]; 259 } 260 if (ReadCount != Counters.size()) { 261 errs() << "WARNING: profile information is inconsistent with " 262 << "the current program!\n"; 263 } 264 } 265 266 return false; 267 } 268
