Home | History | Annotate | Download | only in CodeGen 
      1 //===- MachineBlockFrequencyInfo.cpp - MBB Frequency Analysis -------------===//
      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 // Loops should be simplified before this analysis.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
     15 #include "llvm/Analysis/BlockFrequencyInfoImpl.h"
     16 #include "llvm/CodeGen/MachineBranchProbabilityInfo.h"
     17 #include "llvm/CodeGen/MachineFunction.h"
     18 #include "llvm/CodeGen/MachineLoopInfo.h"
     19 #include "llvm/CodeGen/Passes.h"
     20 #include "llvm/InitializePasses.h"
     21 #include "llvm/Support/CommandLine.h"
     22 #include "llvm/Support/Debug.h"
     23 #include "llvm/Support/GraphWriter.h"
     24 
     25 using namespace llvm;
     26 
     27 #define DEBUG_TYPE "block-freq"
     28 
     29 #ifndef NDEBUG
     30 enum GVDAGType {
     31   GVDT_None,
     32   GVDT_Fraction,
     33   GVDT_Integer
     34 };
     35 
     36 static cl::opt<GVDAGType>
     37 ViewMachineBlockFreqPropagationDAG("view-machine-block-freq-propagation-dags",
     38                                    cl::Hidden,
     39           cl::desc("Pop up a window to show a dag displaying how machine block "
     40                    "frequencies propagate through the CFG."),
     41           cl::values(
     42             clEnumValN(GVDT_None, "none",
     43                        "do not display graphs."),
     44             clEnumValN(GVDT_Fraction, "fraction", "display a graph using the "
     45                        "fractional block frequency representation."),
     46             clEnumValN(GVDT_Integer, "integer", "display a graph using the raw "
     47                        "integer fractional block frequency representation."),
     48             clEnumValEnd));
     49 
     50 namespace llvm {
     51 
     52 template <>
     53 struct GraphTraits<MachineBlockFrequencyInfo *> {
     54   typedef const MachineBasicBlock NodeType;
     55   typedef MachineBasicBlock::const_succ_iterator ChildIteratorType;
     56   typedef MachineFunction::const_iterator nodes_iterator;
     57 
     58   static inline
     59   const NodeType *getEntryNode(const MachineBlockFrequencyInfo *G) {
     60     return &G->getFunction()->front();
     61   }
     62 
     63   static ChildIteratorType child_begin(const NodeType *N) {
     64     return N->succ_begin();
     65   }
     66 
     67   static ChildIteratorType child_end(const NodeType *N) {
     68     return N->succ_end();
     69   }
     70 
     71   static nodes_iterator nodes_begin(const MachineBlockFrequencyInfo *G) {
     72     return G->getFunction()->begin();
     73   }
     74 
     75   static nodes_iterator nodes_end(const MachineBlockFrequencyInfo *G) {
     76     return G->getFunction()->end();
     77   }
     78 };
     79 
     80 template<>
     81 struct DOTGraphTraits<MachineBlockFrequencyInfo*> :
     82     public DefaultDOTGraphTraits {
     83   explicit DOTGraphTraits(bool isSimple=false) :
     84     DefaultDOTGraphTraits(isSimple) {}
     85 
     86   static std::string getGraphName(const MachineBlockFrequencyInfo *G) {
     87     return G->getFunction()->getName();
     88   }
     89 
     90   std::string getNodeLabel(const MachineBasicBlock *Node,
     91                            const MachineBlockFrequencyInfo *Graph) {
     92     std::string Result;
     93     raw_string_ostream OS(Result);
     94 
     95     OS << Node->getName().str() << ":";
     96     switch (ViewMachineBlockFreqPropagationDAG) {
     97     case GVDT_Fraction:
     98       Graph->printBlockFreq(OS, Node);
     99       break;
    100     case GVDT_Integer:
    101       OS << Graph->getBlockFreq(Node).getFrequency();
    102       break;
    103     case GVDT_None:
    104       llvm_unreachable("If we are not supposed to render a graph we should "
    105                        "never reach this point.");
    106     }
    107 
    108     return Result;
    109   }
    110 };
    111 
    112 
    113 } // end namespace llvm
    114 #endif
    115 
    116 INITIALIZE_PASS_BEGIN(MachineBlockFrequencyInfo, "machine-block-freq",
    117                       "Machine Block Frequency Analysis", true, true)
    118 INITIALIZE_PASS_DEPENDENCY(MachineBranchProbabilityInfo)
    119 INITIALIZE_PASS_DEPENDENCY(MachineLoopInfo)
    120 INITIALIZE_PASS_END(MachineBlockFrequencyInfo, "machine-block-freq",
    121                     "Machine Block Frequency Analysis", true, true)
    122 
    123 char MachineBlockFrequencyInfo::ID = 0;
    124 
    125 
    126 MachineBlockFrequencyInfo::
    127 MachineBlockFrequencyInfo() :MachineFunctionPass(ID) {
    128   initializeMachineBlockFrequencyInfoPass(*PassRegistry::getPassRegistry());
    129 }
    130 
    131 MachineBlockFrequencyInfo::~MachineBlockFrequencyInfo() {}
    132 
    133 void MachineBlockFrequencyInfo::getAnalysisUsage(AnalysisUsage &AU) const {
    134   AU.addRequired<MachineBranchProbabilityInfo>();
    135   AU.addRequired<MachineLoopInfo>();
    136   AU.setPreservesAll();
    137   MachineFunctionPass::getAnalysisUsage(AU);
    138 }
    139 
    140 bool MachineBlockFrequencyInfo::runOnMachineFunction(MachineFunction &F) {
    141   MachineBranchProbabilityInfo &MBPI =
    142       getAnalysis<MachineBranchProbabilityInfo>();
    143   MachineLoopInfo &MLI = getAnalysis<MachineLoopInfo>();
    144   if (!MBFI)
    145     MBFI.reset(new ImplType);
    146   MBFI->calculate(F, MBPI, MLI);
    147 #ifndef NDEBUG
    148   if (ViewMachineBlockFreqPropagationDAG != GVDT_None) {
    149     view();
    150   }
    151 #endif
    152   return false;
    153 }
    154 
    155 void MachineBlockFrequencyInfo::releaseMemory() { MBFI.reset(); }
    156 
    157 /// Pop up a ghostview window with the current block frequency propagation
    158 /// rendered using dot.
    159 void MachineBlockFrequencyInfo::view() const {
    160 // This code is only for debugging.
    161 #ifndef NDEBUG
    162   ViewGraph(const_cast<MachineBlockFrequencyInfo *>(this),
    163             "MachineBlockFrequencyDAGs");
    164 #else
    165   errs() << "MachineBlockFrequencyInfo::view is only available in debug builds "
    166     "on systems with Graphviz or gv!\n";
    167 #endif // NDEBUG
    168 }
    169 
    170 BlockFrequency MachineBlockFrequencyInfo::
    171 getBlockFreq(const MachineBasicBlock *MBB) const {
    172   return MBFI ? MBFI->getBlockFreq(MBB) : 0;
    173 }
    174 
    175 const MachineFunction *MachineBlockFrequencyInfo::getFunction() const {
    176   return MBFI ? MBFI->getFunction() : nullptr;
    177 }
    178 
    179 raw_ostream &
    180 MachineBlockFrequencyInfo::printBlockFreq(raw_ostream &OS,
    181                                           const BlockFrequency Freq) const {
    182   return MBFI ? MBFI->printBlockFreq(OS, Freq) : OS;
    183 }
    184 
    185 raw_ostream &
    186 MachineBlockFrequencyInfo::printBlockFreq(raw_ostream &OS,
    187                                           const MachineBasicBlock *MBB) const {
    188   return MBFI ? MBFI->printBlockFreq(OS, MBB) : OS;
    189 }
    190 
    191 uint64_t MachineBlockFrequencyInfo::getEntryFreq() const {
    192   return MBFI ? MBFI->getEntryFreq() : 0;
    193 }
    194