1 //===- RegAllocScore.cpp - evaluate regalloc policy quality ---------------===//
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 /// Calculate a measure of the register allocation policy quality. This is used
9 /// to construct a reward for the training of the ML-driven allocation policy.
10 /// Currently, the score is the sum of the machine basic block frequency-weighed
11 /// number of loads, stores, copies, and remat instructions, each factored with
12 /// a relative weight.
13 //===----------------------------------------------------------------------===//
14
15 #include "RegAllocScore.h"
16 #include "llvm/ADT/DenseMapInfo.h"
17 #include "llvm/ADT/STLForwardCompat.h"
18 #include "llvm/ADT/SetVector.h"
19 #include "llvm/ADT/ilist_iterator.h"
20 #include "llvm/CodeGen/MachineBasicBlock.h"
21 #include "llvm/CodeGen/MachineBlockFrequencyInfo.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/CodeGen/MachineInstr.h"
24 #include "llvm/CodeGen/MachineInstrBundleIterator.h"
25 #include "llvm/CodeGen/TargetInstrInfo.h"
26 #include "llvm/CodeGen/TargetSubtargetInfo.h"
27 #include "llvm/MC/MCInstrDesc.h"
28 #include "llvm/Support/CommandLine.h"
29
30 using namespace llvm;
31 cl::opt<double> CopyWeight("regalloc-copy-weight", cl::init(0.2), cl::Hidden);
32 cl::opt<double> LoadWeight("regalloc-load-weight", cl::init(4.0), cl::Hidden);
33 cl::opt<double> StoreWeight("regalloc-store-weight", cl::init(1.0), cl::Hidden);
34 cl::opt<double> CheapRematWeight("regalloc-cheap-remat-weight", cl::init(0.2),
35 cl::Hidden);
36 cl::opt<double> ExpensiveRematWeight("regalloc-expensive-remat-weight",
37 cl::init(1.0), cl::Hidden);
38 #define DEBUG_TYPE "regalloc-score"
39
operator +=(const RegAllocScore & Other)40 RegAllocScore &RegAllocScore::operator+=(const RegAllocScore &Other) {
41 CopyCounts += Other.copyCounts();
42 LoadCounts += Other.loadCounts();
43 StoreCounts += Other.storeCounts();
44 LoadStoreCounts += Other.loadStoreCounts();
45 CheapRematCounts += Other.cheapRematCounts();
46 ExpensiveRematCounts += Other.expensiveRematCounts();
47 return *this;
48 }
49
operator ==(const RegAllocScore & Other) const50 bool RegAllocScore::operator==(const RegAllocScore &Other) const {
51 return copyCounts() == Other.copyCounts() &&
52 loadCounts() == Other.loadCounts() &&
53 storeCounts() == Other.storeCounts() &&
54 loadStoreCounts() == Other.loadStoreCounts() &&
55 cheapRematCounts() == Other.cheapRematCounts() &&
56 expensiveRematCounts() == Other.expensiveRematCounts();
57 }
58
operator !=(const RegAllocScore & Other) const59 bool RegAllocScore::operator!=(const RegAllocScore &Other) const {
60 return !(*this == Other);
61 }
62
getScore() const63 double RegAllocScore::getScore() const {
64 double Ret = 0.0;
65 Ret += CopyWeight * copyCounts();
66 Ret += LoadWeight * loadCounts();
67 Ret += StoreWeight * storeCounts();
68 Ret += (LoadWeight + StoreWeight) * loadStoreCounts();
69 Ret += CheapRematWeight * cheapRematCounts();
70 Ret += ExpensiveRematWeight * expensiveRematCounts();
71
72 return Ret;
73 }
74
75 RegAllocScore
calculateRegAllocScore(const MachineFunction & MF,const MachineBlockFrequencyInfo & MBFI)76 llvm::calculateRegAllocScore(const MachineFunction &MF,
77 const MachineBlockFrequencyInfo &MBFI) {
78 return calculateRegAllocScore(
79 MF,
80 [&](const MachineBasicBlock &MBB) {
81 return MBFI.getBlockFreqRelativeToEntryBlock(&MBB);
82 },
83 [&](const MachineInstr &MI) {
84 return MF.getSubtarget().getInstrInfo()->isTriviallyReMaterializable(
85 MI);
86 });
87 }
88
calculateRegAllocScore(const MachineFunction & MF,llvm::function_ref<double (const MachineBasicBlock &)> GetBBFreq,llvm::function_ref<bool (const MachineInstr &)> IsTriviallyRematerializable)89 RegAllocScore llvm::calculateRegAllocScore(
90 const MachineFunction &MF,
91 llvm::function_ref<double(const MachineBasicBlock &)> GetBBFreq,
92 llvm::function_ref<bool(const MachineInstr &)>
93 IsTriviallyRematerializable) {
94 RegAllocScore Total;
95
96 for (const MachineBasicBlock &MBB : MF) {
97 double BlockFreqRelativeToEntrypoint = GetBBFreq(MBB);
98 RegAllocScore MBBScore;
99
100 for (const MachineInstr &MI : MBB) {
101 if (MI.isDebugInstr() || MI.isKill() || MI.isInlineAsm()) {
102 continue;
103 }
104 if (MI.isCopy()) {
105 MBBScore.onCopy(BlockFreqRelativeToEntrypoint);
106 } else if (IsTriviallyRematerializable(MI)) {
107 if (MI.getDesc().isAsCheapAsAMove()) {
108 MBBScore.onCheapRemat(BlockFreqRelativeToEntrypoint);
109 } else {
110 MBBScore.onExpensiveRemat(BlockFreqRelativeToEntrypoint);
111 }
112 } else if (MI.mayLoad() && MI.mayStore()) {
113 MBBScore.onLoadStore(BlockFreqRelativeToEntrypoint);
114 } else if (MI.mayLoad()) {
115 MBBScore.onLoad(BlockFreqRelativeToEntrypoint);
116 } else if (MI.mayStore()) {
117 MBBScore.onStore(BlockFreqRelativeToEntrypoint);
118 }
119 }
120 Total += MBBScore;
121 }
122 return Total;
123 }
124