LCOV - code coverage report
Current view: top level - include/llvm/Analysis - ProfileSummaryInfo.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 11 13 84.6 %
Date: 2018-10-20 13:21:21 Functions: 1 2 50.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- C++ -*-===//
       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 contains a pass that provides access to profile summary
      11             : // information.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #ifndef LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
      16             : #define LLVM_ANALYSIS_PROFILE_SUMMARY_INFO_H
      17             : 
      18             : #include "llvm/ADT/ArrayRef.h"
      19             : #include "llvm/ADT/DenseMap.h"
      20             : #include "llvm/ADT/SmallSet.h"
      21             : #include "llvm/IR/Function.h"
      22             : #include "llvm/IR/Instructions.h"
      23             : #include "llvm/IR/PassManager.h"
      24             : #include "llvm/IR/ProfileSummary.h"
      25             : #include "llvm/IR/ValueHandle.h"
      26             : #include "llvm/Pass.h"
      27             : #include <memory>
      28             : 
      29             : namespace llvm {
      30             : class BasicBlock;
      31             : class BlockFrequencyInfo;
      32             : class CallSite;
      33             : class ProfileSummary;
      34             : /// Analysis providing profile information.
      35             : ///
      36             : /// This is an immutable analysis pass that provides ability to query global
      37             : /// (program-level) profile information. The main APIs are isHotCount and
      38             : /// isColdCount that tells whether a given profile count is considered hot/cold
      39             : /// based on the profile summary. This also provides convenience methods to
      40             : /// check whether a function is hot or cold.
      41             : 
      42             : // FIXME: Provide convenience methods to determine hotness/coldness of other IR
      43             : // units. This would require making this depend on BFI.
      44          31 : class ProfileSummaryInfo {
      45             : private:
      46             :   Module &M;
      47             :   std::unique_ptr<ProfileSummary> Summary;
      48             :   bool computeSummary();
      49             :   void computeThresholds();
      50             :   // Count thresholds to answer isHotCount and isColdCount queries.
      51             :   Optional<uint64_t> HotCountThreshold, ColdCountThreshold;
      52             :   // True if the working set size of the code is considered huge,
      53             :   // because the number of profile counts required to reach the hot
      54             :   // percentile is above a huge threshold.
      55             :   Optional<bool> HasHugeWorkingSetSize;
      56             : 
      57             : public:
      58       36285 :   ProfileSummaryInfo(Module &M) : M(M) {}
      59             :   ProfileSummaryInfo(ProfileSummaryInfo &&Arg)
      60         182 :       : M(Arg.M), Summary(std::move(Arg.Summary)) {}
      61             : 
      62             :   /// Returns true if profile summary is available.
      63         821 :   bool hasProfileSummary() { return computeSummary(); }
      64             : 
      65             :   /// Returns true if module \c M has sample profile.
      66             :   bool hasSampleProfile() {
      67         588 :     return hasProfileSummary() &&
      68         268 :            Summary->getKind() == ProfileSummary::PSK_Sample;
      69             :   }
      70             : 
      71             :   /// Returns true if module \c M has instrumentation profile.
      72             :   bool hasInstrumentationProfile() {
      73           7 :     return hasProfileSummary() &&
      74           6 :            Summary->getKind() == ProfileSummary::PSK_Instr;
      75             :   }
      76             : 
      77             :   /// Handle the invalidation of this information.
      78             :   ///
      79             :   /// When used as a result of \c ProfileSummaryAnalysis this method will be
      80             :   /// called when the module this was computed for changes. Since profile
      81             :   /// summary is immutable after it is annotated on the module, we return false
      82             :   /// here.
      83           0 :   bool invalidate(Module &, const PreservedAnalyses &,
      84             :                   ModuleAnalysisManager::Invalidator &) {
      85           0 :     return false;
      86             :   }
      87             : 
      88             :   /// Returns the profile count for \p CallInst.
      89             :   Optional<uint64_t> getProfileCount(const Instruction *CallInst,
      90             :                                      BlockFrequencyInfo *BFI);
      91             :   /// Returns true if the working set size of the code is considered huge.
      92             :   bool hasHugeWorkingSetSize();
      93             :   /// Returns true if \p F has hot function entry.
      94             :   bool isFunctionEntryHot(const Function *F);
      95             :   /// Returns true if \p F contains hot code.
      96             :   bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
      97             :   /// Returns true if \p F has cold function entry.
      98             :   bool isFunctionEntryCold(const Function *F);
      99             :   /// Returns true if \p F contains only cold code.
     100             :   bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
     101             :   /// Returns true if \p F is a hot function.
     102             :   bool isHotCount(uint64_t C);
     103             :   /// Returns true if count \p C is considered cold.
     104             :   bool isColdCount(uint64_t C);
     105             :   /// Returns true if BasicBlock \p B is considered hot.
     106             :   bool isHotBB(const BasicBlock *B, BlockFrequencyInfo *BFI);
     107             :   /// Returns true if BasicBlock \p B is considered cold.
     108             :   bool isColdBB(const BasicBlock *B, BlockFrequencyInfo *BFI);
     109             :   /// Returns true if CallSite \p CS is considered hot.
     110             :   bool isHotCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
     111             :   /// Returns true if Callsite \p CS is considered cold.
     112             :   bool isColdCallSite(const CallSite &CS, BlockFrequencyInfo *BFI);
     113             :   /// Returns HotCountThreshold if set. Recompute HotCountThreshold
     114             :   /// if not set.
     115             :   uint64_t getOrCompHotCountThreshold();
     116             :   /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
     117             :   /// if not set.
     118             :   uint64_t getOrCompColdCountThreshold();
     119             :   /// Returns HotCountThreshold if set.
     120             :   uint64_t getHotCountThreshold() {
     121             :     return HotCountThreshold ? HotCountThreshold.getValue() : 0;
     122             :   }
     123             :   /// Returns ColdCountThreshold if set.
     124             :   uint64_t getColdCountThreshold() {
     125             :     return ColdCountThreshold ? ColdCountThreshold.getValue() : 0;
     126             :   }
     127             : };
     128             : 
     129             : /// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
     130             : class ProfileSummaryInfoWrapperPass : public ImmutablePass {
     131             :   std::unique_ptr<ProfileSummaryInfo> PSI;
     132             : 
     133             : public:
     134             :   static char ID;
     135             :   ProfileSummaryInfoWrapperPass();
     136             : 
     137             :   ProfileSummaryInfo *getPSI() {
     138             :     return &*PSI;
     139             :   }
     140             : 
     141             :   bool doInitialization(Module &M) override;
     142             :   bool doFinalization(Module &M) override;
     143       36257 :   void getAnalysisUsage(AnalysisUsage &AU) const override {
     144             :     AU.setPreservesAll();
     145       36257 :   }
     146             : };
     147             : 
     148             : /// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
     149             : class ProfileSummaryAnalysis
     150             :     : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
     151             : public:
     152             :   typedef ProfileSummaryInfo Result;
     153             : 
     154             :   Result run(Module &M, ModuleAnalysisManager &);
     155             : 
     156             : private:
     157             :   friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
     158             :   static AnalysisKey Key;
     159             : };
     160             : 
     161             : /// Printer pass that uses \c ProfileSummaryAnalysis.
     162             : class ProfileSummaryPrinterPass
     163             :     : public PassInfoMixin<ProfileSummaryPrinterPass> {
     164             :   raw_ostream &OS;
     165             : 
     166             : public:
     167           1 :   explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
     168             :   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
     169             : };
     170             : 
     171             : } // end namespace llvm
     172             : 
     173             : #endif

Generated by: LCOV version 1.13