lib/Target/AMDGPU/SISchedule.td

   1 //===-- SISchedule.td - SI Scheduling definitons -------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // MachineModel definitions for Southern Islands (SI)
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 def : PredicateProlog<[{
  15   const SIInstrInfo *TII =
  16     static_cast<const SIInstrInfo*>(SchedModel->getInstrInfo());
  17   (void)TII;
  18 }]>;
  19
  20 def WriteBranch : SchedWrite;
  21 def WriteExport : SchedWrite;
  22 def WriteLDS    : SchedWrite;
  23 def WriteSALU   : SchedWrite;
  24 def WriteSMEM   : SchedWrite;
  25 def WriteVMEM   : SchedWrite;
  26 def WriteBarrier : SchedWrite;
  27
  28 // Vector ALU instructions
  29 def Write32Bit         : SchedWrite;
  30 def WriteQuarterRate32 : SchedWrite;
  31 def WriteFullOrQuarterRate32 : SchedWrite;
  32
  33 def WriteFloatFMA   : SchedWrite;
  34
  35 // Slow quarter rate f64 instruction.
  36 def WriteDouble : SchedWrite;
  37
  38 // half rate f64 instruction (same as v_add_f64)
  39 def WriteDoubleAdd  : SchedWrite;
  40
  41 // Half rate 64-bit instructions.
  42 def Write64Bit : SchedWrite;
  43
  44 // FIXME: Should there be a class for instructions which are VALU
  45 // instructions and have VALU rates, but write to the SALU (i.e. VOPC
  46 // instructions)
  47
  48 class SISchedMachineModel : SchedMachineModel {
  49   let CompleteModel = 0;
  50   // MicroOpBufferSize = 1 means that instructions will always be added
  51   // the ready queue when they become available.  This exposes them
  52   // to the register pressure analysis.
  53   let MicroOpBufferSize = 1;
  54   let IssueWidth = 1;
  55   let PostRAScheduler = 1;
  56
  57   // FIXME:Approximate 2 * branch cost.  Try to hack around bad
  58   // early-ifcvt heuristics. These need improvement to avoid the OOE
  59   // heuristics.
  60   int MispredictPenalty = 20;
  61 }
  62
  63 def SIFullSpeedModel : SISchedMachineModel;
  64 def SIQuarterSpeedModel : SISchedMachineModel;
  65
  66 // XXX: Are the resource counts correct?
  67 def HWBranch : ProcResource<1> {
  68   let BufferSize = 1;
  69 }
  70 def HWExport : ProcResource<1> {
  71   let BufferSize = 7; // Taken from S_WAITCNT
  72 }
  73 def HWLGKM   : ProcResource<1> {
  74   let BufferSize = 31;  // Taken from S_WAITCNT
  75 }
  76 def HWSALU   : ProcResource<1> {
  77   let BufferSize = 1;
  78 }
  79 def HWVMEM   : ProcResource<1> {
  80   let BufferSize = 15;  // Taken from S_WAITCNT
  81 }
  82 def HWVALU   : ProcResource<1> {
  83   let BufferSize = 1;
  84 }
  85
  86 class HWWriteRes<SchedWrite write, list<ProcResourceKind> resources,
  87                  int latency> : WriteRes<write, resources> {
  88   let Latency = latency;
  89 }
  90
  91 class HWVALUWriteRes<SchedWrite write, int latency> :
  92   HWWriteRes<write, [HWVALU], latency>;
  93
  94
  95 // The latency numbers are taken from AMD Accelerated Parallel Processing
  96 // guide. They may not be accurate.
  97
  98 // The latency values are 1 / (operations / cycle) / 4.
  99 multiclass SICommonWriteRes {
 100
 101   def : HWWriteRes<WriteBranch,  [HWBranch], 8>;
 102   def : HWWriteRes<WriteExport,  [HWExport], 4>;
 103   def : HWWriteRes<WriteLDS,     [HWLGKM],   5>; // Can be between 2 and 64
 104   def : HWWriteRes<WriteSALU,    [HWSALU],   1>;
 105   def : HWWriteRes<WriteSMEM,    [HWLGKM],   5>;
 106   def : HWWriteRes<WriteVMEM,    [HWVMEM],   80>;
 107   def : HWWriteRes<WriteBarrier, [HWBranch], 500>; // XXX: Guessed ???
 108
 109   def : HWVALUWriteRes<Write32Bit,         1>;
 110   def : HWVALUWriteRes<Write64Bit,         2>;
 111   def : HWVALUWriteRes<WriteQuarterRate32, 4>;
 112 }
 113
 114 def PredIsVGPR32Copy : SchedPredicate<[{TII->isVGPRCopy(*MI) && TII->getOpSize(*MI, 0) <= 32}]>;
 115 def PredIsVGPR64Copy : SchedPredicate<[{TII->isVGPRCopy(*MI) && TII->getOpSize(*MI, 0) > 32}]>;
 116 def WriteCopy : SchedWriteVariant<[
 117     SchedVar<PredIsVGPR32Copy, [Write32Bit]>,
 118     SchedVar<PredIsVGPR64Copy, [Write64Bit]>,
 119     SchedVar<NoSchedPred, [WriteSALU]>]>;
 120
 121 let SchedModel = SIFullSpeedModel in {
 122
 123 defm : SICommonWriteRes;
 124
 125 def : HWVALUWriteRes<WriteFloatFMA,   1>;
 126 def : HWVALUWriteRes<WriteDouble,     4>;
 127 def : HWVALUWriteRes<WriteDoubleAdd,  2>;
 128
 129 def : InstRW<[WriteCopy], (instrs COPY)>;
 130
 131 } // End SchedModel = SIFullSpeedModel
 132
 133 let SchedModel = SIQuarterSpeedModel in {
 134
 135 defm : SICommonWriteRes;
 136
 137 def : HWVALUWriteRes<WriteFloatFMA, 16>;
 138 def : HWVALUWriteRes<WriteDouble,   16>;
 139 def : HWVALUWriteRes<WriteDoubleAdd, 8>;
 140
 141 def : InstRW<[WriteCopy], (instrs COPY)>;
 142
 143 }  // End SchedModel = SIQuarterSpeedModel