Movatterモバイル変換

Go to the documentation of this file.

1//===- MachineBranchProbabilityInfo.cpp - Machine Branch Probability Info -===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// This analysis uses probability info stored in Machine Basic Blocks.

10//

11//===----------------------------------------------------------------------===//

13#include "llvm/CodeGen/MachineBranchProbabilityInfo.h"

14#include "llvm/CodeGen/MachineBasicBlock.h"

15#include "llvm/InitializePasses.h"

16#include "llvm/Support/CommandLine.h"

17#include "llvm/Support/raw_ostream.h"

19using namespacellvm;

21INITIALIZE_PASS_BEGIN(MachineBranchProbabilityInfoWrapperPass,

22"machine-branch-prob",

23"Machine Branch Probability Analysis",false,true)

24INITIALIZE_PASS_END(MachineBranchProbabilityInfoWrapperPass,

25 "machine-branch-prob",

26 "Machine Branch ProbabilityAnalysis",false,true)

28namespacellvm {

29cl::opt<unsigned>

30StaticLikelyProb("static-likely-prob",

31cl::desc("branch probability threshold in percentage"

32" to be considered very likely"),

33cl::init(80),cl::Hidden);

35cl::opt<unsigned>ProfileLikelyProb(

36"profile-likely-prob",

37cl::desc("branch probability threshold in percentage to be considered"

38" very likely when profile is available"),

39cl::init(51),cl::Hidden);

40}// namespace llvm

42MachineBranchProbabilityAnalysis::Result

43MachineBranchProbabilityAnalysis::run(MachineFunction &,

44MachineFunctionAnalysisManager &) {

45returnMachineBranchProbabilityInfo();

46}

48PreservedAnalyses

49MachineBranchProbabilityPrinterPass::run(MachineFunction &MF,

50MachineFunctionAnalysisManager &MFAM) {

51 OS <<"Printing analysis 'Machine Branch Probability Analysis' for machine "

52"function '"

53 << MF.getName() <<"':\n";

54auto &MBPI = MFAM.getResult<MachineBranchProbabilityAnalysis>(MF);

55for (constMachineBasicBlock &MBB : MF) {

56for (constMachineBasicBlock *Succ :MBB.successors())

57 MBPI.printEdgeProbability(OS <<" ", &MBB, Succ);

58 }

59returnPreservedAnalyses::all();

60}

62charMachineBranchProbabilityInfoWrapperPass::ID = 0;

64MachineBranchProbabilityInfoWrapperPass::

65 MachineBranchProbabilityInfoWrapperPass()

66 :ImmutablePass(ID) {

67PassRegistry &Registry = *PassRegistry::getPassRegistry();

68initializeMachineBranchProbabilityInfoWrapperPassPass(Registry);

69}

71void MachineBranchProbabilityInfoWrapperPass::anchor() {}

73AnalysisKey MachineBranchProbabilityAnalysis::Key;

75boolMachineBranchProbabilityInfo::invalidate(

76MachineFunction &,constPreservedAnalyses &PA,

77MachineFunctionAnalysisManager::Invalidator &) {

78auto PAC = PA.getChecker<MachineBranchProbabilityAnalysis>();

79return !PAC.preservedWhenStateless();

80}

82BranchProbability MachineBranchProbabilityInfo::getEdgeProbability(

83constMachineBasicBlock *Src,

84MachineBasicBlock::const_succ_iterator Dst) const{

85return Src->getSuccProbability(Dst);

86}

88BranchProbability MachineBranchProbabilityInfo::getEdgeProbability(

89constMachineBasicBlock *Src,constMachineBasicBlock *Dst) const{

90// This is a linear search. Try to use the const_succ_iterator version when

91// possible.

92returngetEdgeProbability(Src,find(Src->successors(), Dst));

93}

95boolMachineBranchProbabilityInfo::isEdgeHot(

96constMachineBasicBlock *Src,constMachineBasicBlock *Dst) const{

97BranchProbability HotProb(StaticLikelyProb, 100);

98returngetEdgeProbability(Src, Dst) > HotProb;

99}

100

101raw_ostream &MachineBranchProbabilityInfo::printEdgeProbability(

102raw_ostream &OS,constMachineBasicBlock *Src,

103constMachineBasicBlock *Dst) const{

104

105constBranchProbability Prob =getEdgeProbability(Src, Dst);

106OS <<"edge " <<printMBBReference(*Src) <<" -> " <<printMBBReference(*Dst)

107 <<" probability is " << Prob

108 << (isEdgeHot(Src, Dst) ?" [HOT edge]\n" :"\n");

109

110returnOS;

111}

MBB

MachineBasicBlock & MBB

Definition:ARMSLSHardening.cpp:71

true

basic Basic Alias true

Definition:BasicAliasAnalysis.cpp:1981

Machine

COFF::MachineTypes Machine

Definition:COFFYAML.cpp:390

machine branch Machine Branch Probability Analysis

Definition:MachineBranchProbabilityInfo.cpp:26

prob

machine branch prob

Definition:MachineBranchProbabilityInfo.cpp:25

MachineBranchProbabilityInfo.h

INITIALIZE_PASS_END

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

Definition:PassSupport.h:57

INITIALIZE_PASS_BEGIN

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

Definition:PassSupport.h:52

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

llvm::AnalysisManager::Invalidator

API to communicate dependencies between analyses during invalidation.

Definition:PassManager.h:292

llvm::AnalysisManager

A container for analyses that lazily runs them and caches their results.

Definition:PassManager.h:253

llvm::AnalysisManager::getResult

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Definition:PassManager.h:410

llvm::BranchProbability

Definition:BranchProbability.h:30

llvm::ImmutablePass

ImmutablePass class - This class is used to provide information that does not need to be run.

Definition:Pass.h:281

llvm::MachineBasicBlock

Definition:MachineBasicBlock.h:125

llvm::MachineBasicBlock::const_succ_iterator

SmallVectorImpl< MachineBasicBlock * >::const_iterator const_succ_iterator

Definition:MachineBasicBlock.h:396

llvm::MachineBasicBlock::successors

iterator_range< succ_iterator > successors()

Definition:MachineBasicBlock.h:444

llvm::MachineBranchProbabilityAnalysis

Definition:MachineBranchProbabilityInfo.h:59

llvm::MachineBranchProbabilityAnalysis::run

Result run(MachineFunction &, MachineFunctionAnalysisManager &)

Definition:MachineBranchProbabilityInfo.cpp:43

llvm::MachineBranchProbabilityInfoWrapperPass

Definition:MachineBranchProbabilityInfo.h:80

llvm::MachineBranchProbabilityInfoWrapperPass::ID

static char ID

Definition:MachineBranchProbabilityInfo.h:86

llvm::MachineBranchProbabilityInfoWrapperPass::MachineBranchProbabilityInfoWrapperPass

MachineBranchProbabilityInfoWrapperPass()

Definition:MachineBranchProbabilityInfo.cpp:65

llvm::MachineBranchProbabilityInfo

Definition:MachineBranchProbabilityInfo.h:23

llvm::MachineBranchProbabilityInfo::printEdgeProbability

raw_ostream & printEdgeProbability(raw_ostream &OS, const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const

Definition:MachineBranchProbabilityInfo.cpp:101

llvm::MachineBranchProbabilityInfo::invalidate

bool invalidate(MachineFunction &, const PreservedAnalyses &PA, MachineFunctionAnalysisManager::Invalidator &)

Definition:MachineBranchProbabilityInfo.cpp:75

llvm::MachineBranchProbabilityInfo::isEdgeHot

bool isEdgeHot(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const

Definition:MachineBranchProbabilityInfo.cpp:95

llvm::MachineBranchProbabilityInfo::getEdgeProbability

BranchProbability getEdgeProbability(const MachineBasicBlock *Src, const MachineBasicBlock *Dst) const

Definition:MachineBranchProbabilityInfo.cpp:88

llvm::MachineBranchProbabilityPrinterPass::run

PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

Definition:MachineBranchProbabilityInfo.cpp:49

llvm::MachineFunction

Definition:MachineFunction.h:267

llvm::MachineFunction::getName

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

Definition:MachineFunction.cpp:645

llvm::PassRegistry

PassRegistry - This class manages the registration and intitialization of the pass subsystem as appli...

Definition:PassRegistry.h:37

llvm::PassRegistry::getPassRegistry

static PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

Definition:PassRegistry.cpp:24

llvm::PreservedAnalyses

A set of analyses that are preserved following a run of a transformation pass.

Definition:Analysis.h:111

llvm::PreservedAnalyses::all

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

Definition:Analysis.h:117

llvm::PreservedAnalyses::getChecker

PreservedAnalysisChecker getChecker() const

Build a checker for this PreservedAnalyses and the specified analysis type.

Definition:Analysis.h:264

llvm::Registry

A global registry used in conjunction with static constructors to make pluggable components (like tar...

Definition:Registry.h:44

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::raw_ostream

This class implements an extremely fast bulk output stream that can only output to a stream.

Definition:raw_ostream.h:52

unsigned

false

Definition:StackSlotColoring.cpp:193

llvm::cl::Hidden

@ Hidden

Definition:CommandLine.h:137

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition:CommandLine.h:443

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::find

auto find(R &&Range, const T &Val)

Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.

Definition:STLExtras.h:1759

llvm::ProfileLikelyProb

cl::opt< unsigned > ProfileLikelyProb

llvm::StaticLikelyProb

cl::opt< unsigned > StaticLikelyProb

llvm::initializeMachineBranchProbabilityInfoWrapperPassPass

void initializeMachineBranchProbabilityInfoWrapperPassPass(PassRegistry &)

llvm::printMBBReference

Printable printMBBReference(const MachineBasicBlock &MBB)

Prints a machine basic block reference.

Definition:MachineBasicBlock.cpp:122

raw_ostream.h

llvm::AnalysisKey

A special type used by analysis passes to provide an address that identifies that particular analysis...

Definition:Analysis.h:28

llvm::cl::desc

Definition:CommandLine.h:409