contrib/llvm-project/llvm/lib/Target/AMDGPU/SISchedule.td

   1 //===-- SISchedule.td - SI Scheduling definitions -------------------------===//
   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 // MachineModel definitions for Southern Islands (SI)
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 def : PredicateProlog<[{
  14   const SIInstrInfo *TII =
  15     static_cast<const SIInstrInfo*>(SchedModel->getInstrInfo());
  16   (void)TII;
  17 }]>;
  18
  19 def WriteBranch : SchedWrite;
  20 def WriteExport : SchedWrite;
  21 def WriteLDS    : SchedWrite;
  22 def WriteSALU   : SchedWrite;
  23 def WriteSMEM   : SchedWrite;
  24 def WriteVMEM   : SchedWrite;
  25 def WriteBarrier : SchedWrite;
  26
  27 def MIVGPRRead  : SchedRead;
  28 def MIMFMARead  : SchedRead;
  29
  30 // Normal 16 or 32 bit VALU instructions
  31 def Write32Bit         : SchedWrite;
  32 // Conversion to or from F32 (but not converting F64 to or from F32)
  33 def WriteFloatCvt      : SchedWrite;
  34 // F16 or F32 transcendental instructions (these are quarter rate)
  35 def WriteTrans32       : SchedWrite;
  36 // Other quarter rate VALU instructions
  37 def WriteQuarterRate32 : SchedWrite;
  38
  39 def WriteFloatFMA   : SchedWrite;
  40
  41 // Slow quarter rate f64 instruction.
  42 def WriteDouble : SchedWrite;
  43
  44 // half rate f64 instruction (same as v_add_f64)
  45 def WriteDoubleAdd  : SchedWrite;
  46
  47 // Conversion to or from f64 instruction
  48 def WriteDoubleCvt  : SchedWrite;
  49
  50 // F64 "transcendental" (actually only reciprocal and/or square root)
  51 // instructions
  52 def WriteTrans64    : SchedWrite;
  53
  54 // Half rate 64-bit instructions.
  55 def Write64Bit : SchedWrite;
  56
  57 // mAI multipass instructions.
  58 def Write2PassMAI  : SchedWrite;
  59 def Write8PassMAI  : SchedWrite;
  60 def Write16PassMAI : SchedWrite;
  61
  62 // FIXME: Should there be a class for instructions which are VALU
  63 // instructions and have VALU rates, but write to the SALU (i.e. VOPC
  64 // instructions)
  65
  66 class SISchedMachineModel : SchedMachineModel {
  67   let CompleteModel = 1;
  68   // MicroOpBufferSize = 1 means that instructions will always be added
  69   // the ready queue when they become available.  This exposes them
  70   // to the register pressure analysis.
  71   let MicroOpBufferSize = 1;
  72   let IssueWidth = 1;
  73   let PostRAScheduler = 1;
  74
  75   // FIXME:Approximate 2 * branch cost.  Try to hack around bad
  76   // early-ifcvt heuristics. These need improvement to avoid the OOE
  77   // heuristics.
  78   int MispredictPenalty = 20;
  79 }
  80
  81 def SIFullSpeedModel : SISchedMachineModel;
  82 def SIQuarterSpeedModel : SISchedMachineModel;
  83 def GFX10SpeedModel : SISchedMachineModel;
  84
  85 // XXX: Are the resource counts correct?
  86 def HWBranch : ProcResource<1> {
  87   let BufferSize = 1;
  88 }
  89 def HWExport : ProcResource<1> {
  90   let BufferSize = 7; // Taken from S_WAITCNT
  91 }
  92 def HWLGKM   : ProcResource<1> {
  93   let BufferSize = 31;  // Taken from S_WAITCNT
  94 }
  95 def HWSALU   : ProcResource<1> {
  96   let BufferSize = 1;
  97 }
  98 def HWVMEM   : ProcResource<1> {
  99   let BufferSize = 15;  // Taken from S_WAITCNT
 100 }
 101 def HWVALU   : ProcResource<1> {
 102   let BufferSize = 1;
 103 }
 104 def HWRC   : ProcResource<1> { // Register destination cache
 105   let BufferSize = 1;
 106 }
 107
 108 class HWWriteRes<SchedWrite write, list<ProcResourceKind> resources,
 109                  int latency> : WriteRes<write, resources> {
 110   let Latency = latency;
 111 }
 112
 113 class HWVALUWriteRes<SchedWrite write, int latency> :
 114   HWWriteRes<write, [HWVALU], latency>;
 115
 116 def PredMIReadVGPR : SchedPredicate<[{TII->hasVGPRUses(*MI)}]>;
 117
 118 def MIReadVGPR : SchedReadVariant<[
 119       SchedVar<PredMIReadVGPR, [MIVGPRRead]>,
 120       SchedVar<NoSchedPred, [ReadDefault]>]>;
 121
 122 // The latency numbers are taken from AMD Accelerated Parallel Processing
 123 // guide. They may not be accurate.
 124
 125 // The latency values are 1 / (operations / cycle) / 4.
 126 multiclass SICommonWriteRes {
 127
 128   def : HWWriteRes<WriteBranch,  [HWBranch], 8>;
 129   def : HWWriteRes<WriteExport,  [HWExport], 4>;
 130   def : HWWriteRes<WriteLDS,     [HWLGKM],   5>; // Can be between 2 and 64
 131   def : HWWriteRes<WriteSALU,    [HWSALU],   1>;
 132   def : HWWriteRes<WriteSMEM,    [HWLGKM],   5>;
 133   def : HWWriteRes<WriteVMEM,    [HWVMEM],   80>;
 134   def : HWWriteRes<WriteBarrier, [HWBranch], 500>; // XXX: Guessed ???
 135
 136   def : HWVALUWriteRes<Write32Bit,         1>;
 137   def : HWVALUWriteRes<Write64Bit,         2>;
 138   def : HWVALUWriteRes<WriteFloatCvt,      4>;
 139   def : HWVALUWriteRes<WriteTrans32,       4>;
 140   def : HWVALUWriteRes<WriteQuarterRate32, 4>;
 141   def : HWVALUWriteRes<Write2PassMAI,      2>;
 142   def : HWVALUWriteRes<Write8PassMAI,      8>;
 143   def : HWVALUWriteRes<Write16PassMAI,    16>;
 144
 145   def : ReadAdvance<MIVGPRRead, -2>;
 146   def : InstRW<[Write64Bit, MIReadVGPR], (instregex "^V_ACCVGPR_WRITE_B32$")>;
 147
 148   // Technically mfma reads can be from 0 to 4 cycles but that does not make
 149   // sense to model because its register setup is huge. In particular if we
 150   // properly model read advance as -2 for a vgpr read it will result in a
 151   // bad scheduling of acc writes before that mfma. To avoid it we would
 152   // need to consume 2 or 4 more vgprs to be initialized before the acc
 153   // write sequence. Just assume worst case here.
 154   def : ReadAdvance<MIMFMARead, -4>;
 155
 156   def : InstRW<[Write2PassMAI,  MIMFMARead], (instregex "^V_MFMA_..._4X4X")>;
 157   def : InstRW<[Write8PassMAI,  MIMFMARead], (instregex "^V_MFMA_..._16X16X")>;
 158   def : InstRW<[Write16PassMAI, MIMFMARead], (instregex "^V_MFMA_..._32X32X")>;
 159 }
 160
 161 def PredIsVGPR32Copy : SchedPredicate<[{TII->isVGPRCopy(*MI) && TII->getOpSize(*MI, 0) <= 32}]>;
 162 def PredIsVGPR64Copy : SchedPredicate<[{TII->isVGPRCopy(*MI) && TII->getOpSize(*MI, 0) > 32}]>;
 163 def WriteCopy : SchedWriteVariant<[
 164     SchedVar<PredIsVGPR32Copy, [Write32Bit]>,
 165     SchedVar<PredIsVGPR64Copy, [Write64Bit]>,
 166     SchedVar<NoSchedPred, [WriteSALU]>]>;
 167
 168 let SchedModel = SIFullSpeedModel in {
 169
 170 defm : SICommonWriteRes;
 171
 172 def : HWVALUWriteRes<WriteFloatFMA,   1>;
 173 def : HWVALUWriteRes<WriteDouble,     4>;
 174 def : HWVALUWriteRes<WriteDoubleAdd,  2>;
 175 def : HWVALUWriteRes<WriteDoubleCvt,  4>;
 176 def : HWVALUWriteRes<WriteTrans64,    4>;
 177
 178 def : InstRW<[WriteCopy], (instrs COPY)>;
 179
 180 } // End SchedModel = SIFullSpeedModel
 181
 182 let SchedModel = SIQuarterSpeedModel in {
 183
 184 defm : SICommonWriteRes;
 185
 186 def : HWVALUWriteRes<WriteFloatFMA, 16>;
 187 def : HWVALUWriteRes<WriteDouble,   16>;
 188 def : HWVALUWriteRes<WriteDoubleAdd, 8>;
 189 def : HWVALUWriteRes<WriteDoubleCvt, 4>;
 190 def : HWVALUWriteRes<WriteTrans64,  16>;
 191
 192 def : InstRW<[WriteCopy], (instrs COPY)>;
 193
 194 }  // End SchedModel = SIQuarterSpeedModel
 195
 196 let SchedModel = GFX10SpeedModel in {
 197
 198 // The latency values are 1 / (operations / cycle).
 199 // Add 1 stall cycle for VGPR read.
 200 def : HWWriteRes<Write32Bit,         [HWVALU, HWRC],   5>;
 201 def : HWWriteRes<WriteFloatCvt,      [HWVALU, HWRC],   5>;
 202 def : HWWriteRes<Write64Bit,         [HWVALU, HWRC],   6>;
 203 def : HWWriteRes<WriteTrans32,       [HWVALU, HWRC],   10>;
 204 def : HWWriteRes<WriteQuarterRate32, [HWVALU, HWRC],   8>;
 205 def : HWWriteRes<WriteFloatFMA,      [HWVALU, HWRC],   5>;
 206 def : HWWriteRes<WriteDouble,        [HWVALU, HWRC],   22>;
 207 def : HWWriteRes<WriteDoubleAdd,     [HWVALU, HWRC],   22>;
 208 def : HWWriteRes<WriteDoubleCvt,     [HWVALU, HWRC],   22>;
 209 def : HWWriteRes<WriteTrans64,       [HWVALU, HWRC],   24>;
 210
 211 def : HWWriteRes<WriteBranch,        [HWBranch],       32>;
 212 def : HWWriteRes<WriteExport,        [HWExport, HWRC], 16>;
 213 def : HWWriteRes<WriteLDS,           [HWLGKM,   HWRC], 20>;
 214 def : HWWriteRes<WriteSALU,          [HWSALU,   HWRC], 2>;
 215 def : HWWriteRes<WriteSMEM,          [HWLGKM,   HWRC], 20>;
 216 def : HWWriteRes<WriteVMEM,          [HWVMEM,   HWRC], 320>;
 217 def : HWWriteRes<WriteBarrier,       [HWBranch],       2000>;
 218
 219 def : InstRW<[WriteCopy], (instrs COPY)>;
 220
 221 }  // End SchedModel = GFX10SpeedModel