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/SetVector.h" 17 #include "llvm/Analysis/AliasAnalysis.h" 18 #include "llvm/CodeGen/MachineFrameInfo.h" 19 #include "llvm/CodeGen/MachineRegisterInfo.h" 20 #include "llvm/CodeGen/TargetInstrInfo.h" 21 #include "llvm/Support/Debug.h" 22 #include "llvm/Support/Format.h" 23 #include "llvm/Support/raw_ostream.h" 24 #include "llvm/Target/TargetMachine.h" 25 #include <cassert> 26 #include <cstdint> 27 #include <numeric> 28 #include <vector> 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 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 50 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 59 bool RegAllocScore::operator!=(const RegAllocScore &Other) const { 60 return !(*this == Other); 61 } 62 63 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 76 llvm::calculateRegAllocScore(const MachineFunction &MF, 77 const MachineBlockFrequencyInfo &MBFI, 78 AAResults &AAResults) { 79 return calculateRegAllocScore( 80 MF, 81 [&](const MachineBasicBlock &MBB) { 82 return MBFI.getBlockFreqRelativeToEntryBlock(&MBB); 83 }, 84 [&](const MachineInstr &MI) { 85 return MF.getSubtarget().getInstrInfo()->isTriviallyReMaterializable( 86 MI, &AAResults); 87 }); 88 } 89 90 RegAllocScore llvm::calculateRegAllocScore( 91 const MachineFunction &MF, 92 llvm::function_ref<double(const MachineBasicBlock &)> GetBBFreq, 93 llvm::function_ref<bool(const MachineInstr &)> 94 IsTriviallyRematerializable) { 95 RegAllocScore Total; 96 97 for (const MachineBasicBlock &MBB : MF) { 98 double BlockFreqRelativeToEntrypoint = GetBBFreq(MBB); 99 RegAllocScore MBBScore; 100 101 for (const MachineInstr &MI : MBB) { 102 if (MI.isDebugInstr() || MI.isKill() || MI.isInlineAsm()) { 103 continue; 104 } 105 if (MI.isCopy()) { 106 MBBScore.onCopy(BlockFreqRelativeToEntrypoint); 107 } else if (IsTriviallyRematerializable(MI)) { 108 if (MI.getDesc().isAsCheapAsAMove()) { 109 MBBScore.onCheapRemat(BlockFreqRelativeToEntrypoint); 110 } else { 111 MBBScore.onExpensiveRemat(BlockFreqRelativeToEntrypoint); 112 } 113 } else if (MI.mayLoad() && MI.mayStore()) { 114 MBBScore.onLoadStore(BlockFreqRelativeToEntrypoint); 115 } else if (MI.mayLoad()) { 116 MBBScore.onLoad(BlockFreqRelativeToEntrypoint); 117 } else if (MI.mayStore()) { 118 MBBScore.onStore(BlockFreqRelativeToEntrypoint); 119 } 120 } 121 Total += MBBScore; 122 } 123 return Total; 124 } 125