Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- 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/IR/PassManager.h"

#include "llvm/IR/ProfileSummary.h"

#include "llvm/Pass.h"

#include <memory>

#include <optional>

namespace llvm {

class BasicBlock;

class BlockFrequencyInfo;

class CallBase;

class Function;

/// 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.

  bool isFunctionEntryHot(const Function *F) const;

  /// Returns true if \p F contains hot code.

  bool isFunctionHotInCallGraph(const Function *F,

                                BlockFrequencyInfo &BFI) const;

  /// Returns true if \p F has cold function entry.

  bool isFunctionEntryCold(const Function *F) const;

  /// Returns true if \p F contains only cold code.

  bool isFunctionColdInCallGraph(const Function *F,

                                 BlockFrequencyInfo &BFI) const;

  /// 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.

  bool isFunctionHotInCallGraphNthPercentile(int PercentileCutoff,

                                             const Function *F,

                                             BlockFrequencyInfo &BFI) const;

  /// Returns true if \p F contains cold code with regard to a given cold

  /// percentile cutoff value.

  bool isFunctionColdInCallGraphNthPercentile(int PercentileCutoff,

                                              const Function *F,

                                              BlockFrequencyInfo &BFI) const;

  /// 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.

  bool isHotBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;

  /// Returns true if BasicBlock \p BB is considered cold.

  bool isColdBlock(const BasicBlock *BB, BlockFrequencyInfo *BFI) const;

  /// Returns true if BasicBlock \p BB 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 isHotBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,

                               BlockFrequencyInfo *BFI) const;

  /// 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.

  bool isColdBlockNthPercentile(int PercentileCutoff, const BasicBlock *BB,

                                BlockFrequencyInfo *BFI) const;

  /// 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 <bool isHot>

   bool isFunctionHotOrColdInCallGraphNthPercentile(

       int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) const;

   template <bool isHot>

   bool isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const;

   template <bool isHot>

   bool isHotOrColdBlockNthPercentile(int PercentileCutoff,

                                      const BasicBlock *BB,

                                      BlockFrequencyInfo *BFI) 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