llvm-prof.cpp revision 8c2730e347092e2c62ddb8442252e694bc498aa0
1//===- llvm-prof.cpp - Read in and process llvmprof.out data files --------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This tools is meant for use with the various LLVM profiling instrumentation 11// passes. It reads in the data file produced by executing an instrumented 12// program, and outputs a nice report. 13// 14//===----------------------------------------------------------------------===// 15 16#include "llvm/InstrTypes.h" 17#include "llvm/Module.h" 18#include "llvm/Assembly/AsmAnnotationWriter.h" 19#include "llvm/Analysis/ProfileInfoLoader.h" 20#include "llvm/Bytecode/Reader.h" 21#include "Support/CommandLine.h" 22#include "Support/Signals.h" 23#include <cstdio> 24#include <map> 25#include <set> 26 27using namespace llvm; 28 29namespace { 30 cl::opt<std::string> 31 BytecodeFile(cl::Positional, cl::desc("<program bytecode file>"), 32 cl::Required); 33 34 cl::opt<std::string> 35 ProfileDataFile(cl::Positional, cl::desc("<llvmprof.out file>"), 36 cl::Optional, cl::init("llvmprof.out")); 37 38 cl::opt<bool> 39 PrintAnnotatedLLVM("annotated-llvm", 40 cl::desc("Print LLVM code with frequency annotations")); 41 cl::alias PrintAnnotated2("A", cl::desc("Alias for --annotated-llvm"), 42 cl::aliasopt(PrintAnnotatedLLVM)); 43 cl::opt<bool> 44 PrintAllCode("print-all-code", 45 cl::desc("Print annotated code for the entire program")); 46} 47 48// PairSecondSort - A sorting predicate to sort by the second element of a pair. 49template<class T> 50struct PairSecondSortReverse 51 : public std::binary_function<std::pair<T, unsigned>, 52 std::pair<T, unsigned>, bool> { 53 bool operator()(const std::pair<T, unsigned> &LHS, 54 const std::pair<T, unsigned> &RHS) const { 55 return LHS.second > RHS.second; 56 } 57}; 58 59namespace { 60 class ProfileAnnotator : public AssemblyAnnotationWriter { 61 std::map<const Function *, unsigned> &FuncFreqs; 62 std::map<const BasicBlock*, unsigned> &BlockFreqs; 63 std::map<ProfileInfoLoader::Edge, unsigned> &EdgeFreqs; 64 public: 65 ProfileAnnotator(std::map<const Function *, unsigned> &FF, 66 std::map<const BasicBlock*, unsigned> &BF, 67 std::map<ProfileInfoLoader::Edge, unsigned> &EF) 68 : FuncFreqs(FF), BlockFreqs(BF), EdgeFreqs(EF) {} 69 70 virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) { 71 OS << ";;; %" << F->getName() << " called " << FuncFreqs[F] 72 << " times.\n;;;\n"; 73 } 74 virtual void emitBasicBlockStartAnnot(const BasicBlock *BB, 75 std::ostream &OS) { 76 if (BlockFreqs.empty()) return; 77 if (unsigned Count = BlockFreqs[BB]) 78 OS << "\t;;; Basic block executed " << Count << " times.\n"; 79 else 80 OS << "\t;;; Never executed!\n"; 81 } 82 83 virtual void emitBasicBlockEndAnnot(const BasicBlock *BB, std::ostream &OS){ 84 if (EdgeFreqs.empty()) return; 85 86 // Figure out how many times each successor executed. 87 std::vector<std::pair<const BasicBlock*, unsigned> > SuccCounts; 88 const TerminatorInst *TI = BB->getTerminator(); 89 90 std::map<ProfileInfoLoader::Edge, unsigned>::iterator I = 91 EdgeFreqs.lower_bound(std::make_pair(const_cast<BasicBlock*>(BB), 0U)); 92 for (; I != EdgeFreqs.end() && I->first.first == BB; ++I) 93 if (I->second) 94 SuccCounts.push_back(std::make_pair(TI->getSuccessor(I->first.second), 95 I->second)); 96 if (!SuccCounts.empty()) { 97 OS << "\t;;; Out-edge counts:"; 98 for (unsigned i = 0, e = SuccCounts.size(); i != e; ++i) 99 OS << " [" << SuccCounts[i].second << " -> " 100 << SuccCounts[i].first->getName() << "]"; 101 OS << "\n"; 102 } 103 } 104 }; 105} 106 107 108int main(int argc, char **argv) { 109 cl::ParseCommandLineOptions(argc, argv, " llvm profile dump decoder\n"); 110 PrintStackTraceOnErrorSignal(); 111 112 // Read in the bytecode file... 113 std::string ErrorMessage; 114 Module *M = ParseBytecodeFile(BytecodeFile, &ErrorMessage); 115 if (M == 0) { 116 std::cerr << argv[0] << ": " << BytecodeFile << ": " << ErrorMessage 117 << "\n"; 118 return 1; 119 } 120 121 // Read the profiling information 122 ProfileInfoLoader PI(argv[0], ProfileDataFile, *M); 123 124 std::map<const Function *, unsigned> FuncFreqs; 125 std::map<const BasicBlock*, unsigned> BlockFreqs; 126 std::map<ProfileInfoLoader::Edge, unsigned> EdgeFreqs; 127 128 // Output a report. Eventually, there will be multiple reports selectable on 129 // the command line, for now, just keep things simple. 130 131 // Emit the most frequent function table... 132 std::vector<std::pair<Function*, unsigned> > FunctionCounts; 133 PI.getFunctionCounts(FunctionCounts); 134 FuncFreqs.insert(FunctionCounts.begin(), FunctionCounts.end()); 135 136 // Sort by the frequency, backwards. 137 std::sort(FunctionCounts.begin(), FunctionCounts.end(), 138 PairSecondSortReverse<Function*>()); 139 140 unsigned long long TotalExecutions = 0; 141 for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i) 142 TotalExecutions += FunctionCounts[i].second; 143 144 std::cout << "===" << std::string(73, '-') << "===\n" 145 << "LLVM profiling output for execution"; 146 if (PI.getNumExecutions() != 1) std::cout << "s"; 147 std::cout << ":\n"; 148 149 for (unsigned i = 0, e = PI.getNumExecutions(); i != e; ++i) { 150 std::cout << " "; 151 if (e != 1) std::cout << i+1 << ". "; 152 std::cout << PI.getExecution(i) << "\n"; 153 } 154 155 std::cout << "\n===" << std::string(73, '-') << "===\n"; 156 std::cout << "Function execution frequencies:\n\n"; 157 158 // Print out the function frequencies... 159 printf(" ## Frequency\n"); 160 for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i) { 161 if (FunctionCounts[i].second == 0) { 162 printf("\n NOTE: %d function%s never executed!\n", 163 e-i, e-i-1 ? "s were" : " was"); 164 break; 165 } 166 167 printf("%3d. %5u/%llu %s\n", i+1, FunctionCounts[i].second, TotalExecutions, 168 FunctionCounts[i].first->getName().c_str()); 169 } 170 171 std::set<Function*> FunctionsToPrint; 172 173 // If we have block count information, print out the LLVM module with 174 // frequency annotations. 175 if (PI.hasAccurateBlockCounts()) { 176 std::vector<std::pair<BasicBlock*, unsigned> > Counts; 177 PI.getBlockCounts(Counts); 178 179 TotalExecutions = 0; 180 for (unsigned i = 0, e = Counts.size(); i != e; ++i) 181 TotalExecutions += Counts[i].second; 182 183 // Sort by the frequency, backwards. 184 std::sort(Counts.begin(), Counts.end(), 185 PairSecondSortReverse<BasicBlock*>()); 186 187 std::cout << "\n===" << std::string(73, '-') << "===\n"; 188 std::cout << "Top 20 most frequently executed basic blocks:\n\n"; 189 190 // Print out the function frequencies... 191 printf(" ## %%%% \tFrequency\n"); 192 unsigned BlocksToPrint = Counts.size(); 193 if (BlocksToPrint > 20) BlocksToPrint = 20; 194 for (unsigned i = 0; i != BlocksToPrint; ++i) { 195 if (Counts[i].second == 0) break; 196 Function *F = Counts[i].first->getParent(); 197 printf("%3d. %5.2f%% %5u/%llu\t%s() - %s\n", i+1, 198 Counts[i].second/(double)TotalExecutions*100, 199 Counts[i].second, TotalExecutions, 200 F->getName().c_str(), Counts[i].first->getName().c_str()); 201 FunctionsToPrint.insert(F); 202 } 203 204 BlockFreqs.insert(Counts.begin(), Counts.end()); 205 } 206 207 if (PI.hasAccurateEdgeCounts()) { 208 std::vector<std::pair<ProfileInfoLoader::Edge, unsigned> > Counts; 209 PI.getEdgeCounts(Counts); 210 EdgeFreqs.insert(Counts.begin(), Counts.end()); 211 } 212 213 if (PrintAnnotatedLLVM || PrintAllCode) { 214 std::cout << "\n===" << std::string(73, '-') << "===\n"; 215 std::cout << "Annotated LLVM code for the module:\n\n"; 216 217 ProfileAnnotator PA(FuncFreqs, BlockFreqs, EdgeFreqs); 218 219 if (FunctionsToPrint.empty() || PrintAllCode) 220 M->print(std::cout, &PA); 221 else 222 // Print just a subset of the functions... 223 for (std::set<Function*>::iterator I = FunctionsToPrint.begin(), 224 E = FunctionsToPrint.end(); I != E; ++I) 225 (*I)->print(std::cout, &PA); 226 } 227 228 return 0; 229} 230