llvm/lib/CodeGen/RegAllocScore.h

   1 //==- RegAllocScore.h - evaluate regalloc policy quality  ----------*-C++-*-==//
   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 #ifndef LLVM_CODEGEN_REGALLOCSCORE_H_
  16 #define LLVM_CODEGEN_REGALLOCSCORE_H_
  17
  18 #include "llvm/ADT/STLFunctionalExtras.h"
  19
  20 namespace llvm {
  21
  22 class MachineBasicBlock;
  23 class MachineBlockFrequencyInfo;
  24 class MachineFunction;
  25 class MachineInstr;
  26
  27 /// Regalloc score.
  28 class RegAllocScore final {
  29   double CopyCounts = 0.0;
  30   double LoadCounts = 0.0;
  31   double StoreCounts = 0.0;
  32   double CheapRematCounts = 0.0;
  33   double LoadStoreCounts = 0.0;
  34   double ExpensiveRematCounts = 0.0;
  35
  36 public:
  37   RegAllocScore() = default;
  38   RegAllocScore(const RegAllocScore &) = default;
  39
  40   double copyCounts() const { return CopyCounts; }
  41   double loadCounts() const { return LoadCounts; }
  42   double storeCounts() const { return StoreCounts; }
  43   double loadStoreCounts() const { return LoadStoreCounts; }
  44   double expensiveRematCounts() const { return ExpensiveRematCounts; }
  45   double cheapRematCounts() const { return CheapRematCounts; }
  46
  47   void onCopy(double Freq) { CopyCounts += Freq; }
  48   void onLoad(double Freq) { LoadCounts += Freq; }
  49   void onStore(double Freq) { StoreCounts += Freq; }
  50   void onLoadStore(double Freq) { LoadStoreCounts += Freq; }
  51   void onExpensiveRemat(double Freq) { ExpensiveRematCounts += Freq; }
  52   void onCheapRemat(double Freq) { CheapRematCounts += Freq; }
  53
  54   RegAllocScore &operator+=(const RegAllocScore &Other);
  55   bool operator==(const RegAllocScore &Other) const;
  56   bool operator!=(const RegAllocScore &Other) const;
  57   double getScore() const;
  58 };
  59
  60 /// Calculate a score. When comparing 2 scores for the same function but
  61 /// different policies, the better policy would have a smaller score.
  62 /// The implementation is the overload below (which is also easily unittestable)
  63 RegAllocScore calculateRegAllocScore(const MachineFunction &MF,
  64                                      const MachineBlockFrequencyInfo &MBFI);
  65
  66 /// Implementation of the above, which is also more easily unittestable.
  67 RegAllocScore calculateRegAllocScore(
  68     const MachineFunction &MF,
  69     llvm::function_ref<double(const MachineBasicBlock &)> GetBBFreq,
  70     llvm::function_ref<bool(const MachineInstr &)> IsTriviallyRematerializable);
  71 } // end namespace llvm
  72
  73 #endif // LLVM_CODEGEN_REGALLOCSCORE_H_