ProfileSummaryInfo.h

Go to the documentation of this file.

//===- llvm/Analysis/ProfileSummaryInfo.h - profile summary ---*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains a pass that provides access to profile summary
// information.
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_ANALYSIS_PROFILESUMMARYINFO_H
#define LLVM_ANALYSIS_PROFILESUMMARYINFO_H
 
#include "llvm/ADT/DenseMap.h"
#include "llvm/Analysis/BlockFrequencyInfo.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/PassManager.h"
#include "llvm/IR/ProfileSummary.h"
#include "llvm/Pass.h"
#include <memory>
#include <optional>
 
namespace llvm {
class BasicBlock;
class CallBase;
class MachineFunction;
 
/// Analysis providing profile information.
///
/// This is an immutable analysis pass that provides ability to query global
/// (program-level) profile information. The main APIs are isHotCount and
/// isColdCount that tells whether a given profile count is considered hot/cold
/// based on the profile summary. This also provides convenience methods to
/// check whether a function is hot or cold.
 
// FIXME: Provide convenience methods to determine hotness/coldness of other IR
// units. This would require making this depend on BFI.
class ProfileSummaryInfo {
private:
  const Module *M;
  std::unique_ptr<ProfileSummary> Summary;
  void computeThresholds();
  // Count thresholds to answer isHotCount and isColdCount queries.
  std::optional<uint64_t> HotCountThreshold, ColdCountThreshold;
  // True if the working set size of the code is considered huge,
  // because the number of profile counts required to reach the hot
  // percentile is above a huge threshold.
  std::optional<bool> HasHugeWorkingSetSize;
  // True if the working set size of the code is considered large,
  // because the number of profile counts required to reach the hot
  // percentile is above a large threshold.
  std::optional<bool> HasLargeWorkingSetSize;
  // Compute the threshold for a given cutoff.
  std::optional<uint64_t> computeThreshold(int PercentileCutoff) const;
  // The map that caches the threshold values. The keys are the percentile
  // cutoff values and the values are the corresponding threshold values.
  mutable DenseMap<int, uint64_t> ThresholdCache;
 
public:
  ProfileSummaryInfo(const Module &M) : M(&M) { refresh(); }
  ProfileSummaryInfo(ProfileSummaryInfo &&Arg) = default;
 
  /// If no summary is present, attempt to refresh.
  void refresh();
 
  /// Returns true if profile summary is available.
  bool hasProfileSummary() const { return Summary != nullptr; }
 
  /// Returns true if module \c M has sample profile.
  bool hasSampleProfile() const {
    return hasProfileSummary() &&
           Summary->getKind() == ProfileSummary::PSK_Sample;
  }
 
  /// Returns true if module \c M has instrumentation profile.
  bool hasInstrumentationProfile() const {
    return hasProfileSummary() &&
           Summary->getKind() == ProfileSummary::PSK_Instr;
  }
 
  /// Returns true if module \c M has context sensitive instrumentation profile.
  bool hasCSInstrumentationProfile() const {
    return hasProfileSummary() &&
           Summary->getKind() == ProfileSummary::PSK_CSInstr;
  }
 
  /// Handle the invalidation of this information.
  ///
  /// When used as a result of \c ProfileSummaryAnalysis this method will be
  /// called when the module this was computed for changes. Since profile
  /// summary is immutable after it is annotated on the module, we return false
  /// here.
  bool invalidate(Module &, const PreservedAnalyses &,
                  ModuleAnalysisManager::Invalidator &) {
    return false;
  }
 
  /// Returns the profile count for \p CallInst.
  std::optional<uint64_t> getProfileCount(const CallBase &CallInst,
                                          BlockFrequencyInfo *BFI,
                                          bool AllowSynthetic = false) const;
  /// Returns true if module \c M has partial-profile sample profile.
  bool hasPartialSampleProfile() const;
  /// Returns true if the working set size of the code is considered huge.
  bool hasHugeWorkingSetSize() const;
  /// Returns true if the working set size of the code is considered large.
  bool hasLargeWorkingSetSize() const;
  /// Returns true if \p F has hot function entry. If it returns false, it
  /// either means it is not hot or it is unknown whether it is hot or not (for
  /// example, no profile data is available).
  template <typename FuncT> bool isFunctionEntryHot(const FuncT *F) const {
    if (!F || !hasProfileSummary())
      return false;
    std::optional<Function::ProfileCount> FunctionCount = getEntryCount(F);
    // FIXME: The heuristic used below for determining hotness is based on
    // preliminary SPEC tuning for inliner. This will eventually be a
    // convenience method that calls isHotCount.
    return FunctionCount && isHotCount(FunctionCount->getCount());
  }
 
  /// Returns true if \p F contains hot code.
  template <typename FuncT, typename BFIT>
  bool isFunctionHotInCallGraph(const FuncT *F, BFIT &BFI) const {
    if (!F || !hasProfileSummary())
      return false;
    if (auto FunctionCount = getEntryCount(F))
      if (isHotCount(FunctionCount->getCount()))
        return true;
 
    if (auto TotalCallCount = getTotalCallCount(F))
      if (isHotCount(*TotalCallCount))
        return true;
 
    for (const auto &BB : *F)
      if (isHotBlock(&BB, &BFI))
        return true;
    return false;
  }
  /// Returns true if \p F has cold function entry.
  bool isFunctionEntryCold(const Function *F) const;
  /// Returns true if \p F contains only cold code.
  template <typename FuncT, typename BFIT>
  bool isFunctionColdInCallGraph(const FuncT *F, BFIT &BFI) const {
    if (!F || !hasProfileSummary())
      return false;
    if (auto FunctionCount = getEntryCount(F))
      if (!isColdCount(FunctionCount->getCount()))
        return false;
 
    if (auto TotalCallCount = getTotalCallCount(F))
      if (!isColdCount(*TotalCallCount))
        return false;
 
    for (const auto &BB : *F)
      if (!isColdBlock(&BB, &BFI))
        return false;
    return true;
  }
  /// Returns true if the hotness of \p F is unknown.
  bool isFunctionHotnessUnknown(const Function &F) const;
  /// Returns true if \p F contains hot code with regard to a given hot
  /// percentile cutoff value.
  template <typename FuncT, typename BFIT>
  bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,
                                             const FuncT *F, BFIT &BFI) const {
    return isFunctionHotOrColdInCallGraphNthPercentile<true, FuncT, BFIT>(
        PercentileCutoff, F, BFI);
  }
  /// Returns true if \p F contains cold code with regard to a given cold
  /// percentile cutoff value.
  template <typename FuncT, typename BFIT>
  bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,
                                              const FuncT *F, BFIT &BFI) const {
    return isFunctionHotOrColdInCallGraphNthPercentile<false, FuncT, BFIT>(
        PercentileCutoff, F, BFI);
  }
  /// Returns true if count \p C is considered hot.
  bool isHotCount(uint64_t C) const;
  /// Returns true if count \p C is considered cold.
  bool isColdCount(uint64_t C) const;
  /// Returns true if count \p C is considered hot with regard to a given
  /// hot percentile cutoff value.
  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
  bool isHotCountNthPercentile(int PercentileCutoff, uint64_t C) const;
  /// Returns true if count \p C is considered cold with regard to a given
  /// cold percentile cutoff value.
  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
  bool isColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
 
  /// Returns true if BasicBlock \p BB is considered hot.
  template <typename BBType, typename BFIT>
  bool isHotBlock(const BBType *BB, BFIT *BFI) const {
    auto Count = BFI->getBlockProfileCount(BB);
    return Count && isHotCount(*Count);
  }
 
  /// Returns true if BasicBlock \p BB is considered cold.
  template <typename BBType, typename BFIT>
  bool isColdBlock(const BBType *BB, BFIT *BFI) const {
    auto Count = BFI->getBlockProfileCount(BB);
    return Count && isColdCount(*Count);
  }
 
  template <typename BFIT>
  bool isColdBlock(BlockFrequency BlockFreq, const BFIT *BFI) const {
    auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
    return Count && isColdCount(*Count);
  }
 
  template <typename BBType, typename BFIT>
  bool isHotBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                               BFIT *BFI) const {
    return isHotOrColdBlockNthPercentile<true, BBType, BFIT>(PercentileCutoff,
                                                             BB, BFI);
  }
 
  template <typename BFIT>
  bool isHotBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
                               BFIT *BFI) const {
    return isHotOrColdBlockNthPercentile<true, BFIT>(PercentileCutoff,
                                                     BlockFreq, BFI);
  }
 
  /// Returns true if BasicBlock \p BB is considered cold with regard to a given
  /// cold percentile cutoff value.
  /// PercentileCutoff is encoded as a 6 digit decimal fixed point number, where
  /// the first two digits are the whole part. E.g. 995000 for 99.5 percentile.
  template <typename BBType, typename BFIT>
  bool isColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                                BFIT *BFI) const {
    return isHotOrColdBlockNthPercentile<false, BBType, BFIT>(PercentileCutoff,
                                                              BB, BFI);
  }
  template <typename BFIT>
  bool isColdBlockNthPercentile(int PercentileCutoff, BlockFrequency BlockFreq,
                                BFIT *BFI) const {
    return isHotOrColdBlockNthPercentile<false, BFIT>(PercentileCutoff,
                                                      BlockFreq, BFI);
  }
  /// Returns true if the call site \p CB is considered hot.
  bool isHotCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
  /// Returns true if call site \p CB is considered cold.
  bool isColdCallSite(const CallBase &CB, BlockFrequencyInfo *BFI) const;
  /// Returns HotCountThreshold if set. Recompute HotCountThreshold
  /// if not set.
  uint64_t getOrCompHotCountThreshold() const;
  /// Returns ColdCountThreshold if set. Recompute HotCountThreshold
  /// if not set.
  uint64_t getOrCompColdCountThreshold() const;
  /// Returns HotCountThreshold if set.
  uint64_t getHotCountThreshold() const {
    return HotCountThreshold.value_or(0);
  }
  /// Returns ColdCountThreshold if set.
  uint64_t getColdCountThreshold() const {
    return ColdCountThreshold.value_or(0);
  }
 
private:
  template <typename FuncT>
  std::optional<uint64_t> getTotalCallCount(const FuncT *F) const {
    return std::nullopt;
  }
 
  template <bool isHot, typename FuncT, typename BFIT>
  bool isFunctionHotOrColdInCallGraphNthPercentile(int PercentileCutoff,
                                                   const FuncT *F,
                                                   BFIT &FI) const {
    if (!F || !hasProfileSummary())
      return false;
    if (auto FunctionCount = getEntryCount(F)) {
      if (isHot &&
          isHotCountNthPercentile(PercentileCutoff, FunctionCount->getCount()))
        return true;
      if (!isHot && !isColdCountNthPercentile(PercentileCutoff,
                                              FunctionCount->getCount()))
        return false;
    }
    if (auto TotalCallCount = getTotalCallCount(F)) {
      if (isHot && isHotCountNthPercentile(PercentileCutoff, *TotalCallCount))
        return true;
      if (!isHot &&
          !isColdCountNthPercentile(PercentileCutoff, *TotalCallCount))
        return false;
    }
    for (const auto &BB : *F) {
      if (isHot && isHotBlockNthPercentile(PercentileCutoff, &BB, &FI))
        return true;
      if (!isHot && !isColdBlockNthPercentile(PercentileCutoff, &BB, &FI))
        return false;
    }
    return !isHot;
  }
 
  template <bool isHot>
  bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;
 
  template <bool isHot, typename BBType, typename BFIT>
  bool isHotOrColdBlockNthPercentile(int PercentileCutoff, const BBType *BB,
                                     BFIT *BFI) const {
    auto Count = BFI->getBlockProfileCount(BB);
    if (isHot)
      return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
    else
      return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
  }
 
  template <bool isHot, typename BFIT>
  bool isHotOrColdBlockNthPercentile(int PercentileCutoff,
                                     BlockFrequency BlockFreq,
                                     BFIT *BFI) const {
    auto Count = BFI->getProfileCountFromFreq(BlockFreq.getFrequency());
    if (isHot)
      return Count && isHotCountNthPercentile(PercentileCutoff, *Count);
    else
      return Count && isColdCountNthPercentile(PercentileCutoff, *Count);
  }
 
  template <typename FuncT>
  std::optional<Function::ProfileCount> getEntryCount(const FuncT *F) const {
    return F->getEntryCount();
  }
};
 
template <>
inline std::optional<uint64_t>
ProfileSummaryInfo::getTotalCallCount<Function>(const Function *F) const {
  if (!hasSampleProfile())
    return std::nullopt;
  uint64_t TotalCallCount = 0;
  for (const auto &BB : *F)
    for (const auto &I : BB)
      if (isa<CallInst>(I) || isa<InvokeInst>(I))
        if (auto CallCount = getProfileCount(cast<CallBase>(I), nullptr))
          TotalCallCount += *CallCount;
  return TotalCallCount;
}
 
// Declare template specialization for llvm::MachineFunction. Do not implement
// here, because we cannot include MachineFunction header here, that would break
// dependency rules.
template <>
std::optional<Function::ProfileCount>
ProfileSummaryInfo::getEntryCount<MachineFunction>(
    const MachineFunction *F) const;
 
/// An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
class ProfileSummaryInfoWrapperPass : public ImmutablePass {
  std::unique_ptr<ProfileSummaryInfo> PSI;
 
public:
  static char ID;
  ProfileSummaryInfoWrapperPass();
 
  ProfileSummaryInfo &getPSI() { return *PSI; }
  const ProfileSummaryInfo &getPSI() const { return *PSI; }
 
  bool doInitialization(Module &M) override;
  bool doFinalization(Module &M) override;
  void getAnalysisUsage(AnalysisUsage &AU) const override {
    AU.setPreservesAll();
  }
};
 
/// An analysis pass based on the new PM to deliver ProfileSummaryInfo.
class ProfileSummaryAnalysis
    : public AnalysisInfoMixin<ProfileSummaryAnalysis> {
public:
  typedef ProfileSummaryInfo Result;
 
  Result run(Module &M, ModuleAnalysisManager &);
 
private:
  friend AnalysisInfoMixin<ProfileSummaryAnalysis>;
  static AnalysisKey Key;
};
 
/// Printer pass that uses \c ProfileSummaryAnalysis.
class ProfileSummaryPrinterPass
    : public PassInfoMixin<ProfileSummaryPrinterPass> {
  raw_ostream &OS;
 
public:
  explicit ProfileSummaryPrinterPass(raw_ostream &OS) : OS(OS) {}
  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
};
 
} // end namespace llvm
 
#endif