lib/Target/PowerPC/PPCScheduleP9.td

   1 //===-- PPCScheduleP9.td - PPC P9 Scheduling Definitions ---*- tablegen -*-===//
   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 // This file defines the itinerary class data for the POWER9 processor.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 include "PPCInstrInfo.td"
  13
  14 def P9Model : SchedMachineModel {
  15   // The maximum number of instructions to be issued at the same time.
  16   // While a value of 8 is technically correct since 8 instructions can be
  17   // fetched from the instruction cache. However, only 6 instructions may be
  18   // actually dispatched at a time.
  19   let IssueWidth = 8;
  20
  21   // Load latency is 4 or 5 cycles depending on the load. This latency assumes
  22   // that we have a cache hit. For a cache miss the load latency will be more.
  23   // There are two instructions (lxvl, lxvll) that have a latencty of 6 cycles.
  24   // However it is not worth bumping this value up to 6 when the vast majority
  25   // of instructions are 4 or 5 cycles.
  26   let LoadLatency = 5;
  27
  28   // A total of 16 cycles to recover from a branch mispredict.
  29   let MispredictPenalty = 16;
  30
  31   // Try to make sure we have at least 10 dispatch groups in a loop.
  32   // A dispatch group is 6 instructions.
  33   let LoopMicroOpBufferSize = 60;
  34
  35   // As iops are dispatched to a slice, they are held in an independent slice
  36   // issue queue until all register sources and other dependencies have been
  37   // resolved and they can be issued. Each of four execution slices has an
  38   // 11-entry iop issue queue.
  39   let MicroOpBufferSize = 44;
  40
  41   let CompleteModel = 1;
  42
  43   // Do not support QPX (Quad Processing eXtension) or SPE (Signal Procesing
  44   // Engine) on Power 9.
  45   let UnsupportedFeatures = [HasQPX, HasSPE];
  46
  47 }
  48
  49 let SchedModel = P9Model in {
  50
  51   // ***************** Processor Resources *****************
  52
  53   //Dispatcher:
  54   def DISPATCHER : ProcResource<12>;
  55
  56   // Issue Ports
  57   // An instruction can go down one of two issue queues.
  58   // Address Generation (AGEN) mainly for loads and stores.
  59   // Execution (EXEC) for most other instructions.
  60   // Some instructions cannot be run on just any issue queue and may require an
  61   // Even or an Odd queue. The EXECE represents the even queues and the EXECO
  62   // represents the odd queues.
  63   def IP_AGEN : ProcResource<4>;
  64   def IP_EXEC : ProcResource<4>;
  65   def IP_EXECE : ProcResource<2> {
  66     //Even Exec Ports
  67     let Super = IP_EXEC;
  68   }
  69   def IP_EXECO : ProcResource<2> {
  70     //Odd Exec Ports
  71     let Super = IP_EXEC;
  72   }
  73
  74   // Pipeline Groups
  75   // Four ALU (Fixed Point Arithmetic) units in total. Two even, two Odd.
  76   def ALU : ProcResource<4>;
  77   def ALUE : ProcResource<2> {
  78     //Even ALU pipelines
  79     let Super = ALU;
  80   }
  81   def ALUO : ProcResource<2> {
  82     //Odd ALU pipelines
  83     let Super = ALU;
  84   }
  85
  86   // Two DIV (Fixed Point Divide) units.
  87   def DIV : ProcResource<2>;
  88
  89   // Four DP (Floating Point) units in total. Two even, two Odd.
  90   def DP : ProcResource<4>;
  91   def DPE : ProcResource<2> {
  92     //Even DP pipelines
  93     let Super = DP;
  94   }
  95   def DPO : ProcResource<2> {
  96     //Odd DP pipelines
  97     let Super = DP;
  98   }
  99
 100   // Four LS (Load or Store) units.
 101   def LS : ProcResource<4>;
 102
 103   // Two PM (Permute) units.
 104   def PM : ProcResource<2>;
 105
 106   // Only one DFU (Decimal Floating Point and Quad Precision) unit.
 107   def DFU : ProcResource<1>;
 108
 109   // Only one Branch unit.
 110   def BR : ProcResource<1> {
 111     let BufferSize = 16;
 112   }
 113
 114   // Only one CY (Crypto) unit.
 115   def CY : ProcResource<1>;
 116
 117   // ***************** SchedWriteRes Definitions *****************
 118
 119   //Dispatcher
 120   def DISP_1C : SchedWriteRes<[DISPATCHER]> {
 121     let NumMicroOps = 0;
 122     let Latency = 1;
 123   }
 124
 125   // Issue Ports
 126   def IP_AGEN_1C : SchedWriteRes<[IP_AGEN]> {
 127     let NumMicroOps = 0;
 128     let Latency = 1;
 129   }
 130
 131   def IP_EXEC_1C : SchedWriteRes<[IP_EXEC]> {
 132     let NumMicroOps = 0;
 133     let Latency = 1;
 134   }
 135
 136   def IP_EXECE_1C : SchedWriteRes<[IP_EXECE]> {
 137     let NumMicroOps = 0;
 138     let Latency = 1;
 139   }
 140
 141   def IP_EXECO_1C : SchedWriteRes<[IP_EXECO]> {
 142     let NumMicroOps = 0;
 143     let Latency = 1;
 144   }
 145
 146   //Pipeline Groups
 147
 148   // ALU Units
 149   // An ALU may take either 2 or 3 cycles to complete the operation.
 150   // However, the ALU unit is only every busy for 1 cycle at a time and may
 151   // receive new instructions each cycle.
 152   def P9_ALU_2C : SchedWriteRes<[ALU]> {
 153     let Latency = 2;
 154   }
 155
 156   def P9_ALUE_2C : SchedWriteRes<[ALUE]> {
 157     let Latency = 2;
 158   }
 159
 160   def P9_ALUO_2C : SchedWriteRes<[ALUO]> {
 161     let Latency = 2;
 162   }
 163
 164   def P9_ALU_3C : SchedWriteRes<[ALU]> {
 165     let Latency = 3;
 166   }
 167
 168   def P9_ALUE_3C : SchedWriteRes<[ALUE]> {
 169     let Latency = 3;
 170   }
 171
 172   def P9_ALUO_3C : SchedWriteRes<[ALUO]> {
 173     let Latency = 3;
 174   }
 175
 176   // DIV Unit
 177   // A DIV unit may take from 5 to 40 cycles to complete.
 178   // Some DIV operations may keep the unit busy for up to 8 cycles.
 179   def P9_DIV_5C : SchedWriteRes<[DIV]> {
 180     let Latency = 5;
 181   }
 182
 183   def P9_DIV_12C : SchedWriteRes<[DIV]> {
 184     let Latency = 12;
 185   }
 186
 187   def P9_DIV_16C_8 : SchedWriteRes<[DIV]> {
 188     let ResourceCycles = [8];
 189     let Latency = 16;
 190   }
 191
 192   def P9_DIV_24C_8 : SchedWriteRes<[DIV]> {
 193     let ResourceCycles = [8];
 194     let Latency = 24;
 195   }
 196
 197   def P9_DIV_40C_8 : SchedWriteRes<[DIV]> {
 198     let ResourceCycles = [8];
 199     let Latency = 40;
 200   }
 201
 202   // DP Unit
 203   // A DP unit may take from 2 to 36 cycles to complete.
 204   // Some DP operations keep the unit busy for up to 10 cycles.
 205   def P9_DP_2C : SchedWriteRes<[DP]> {
 206     let Latency = 2;
 207   }
 208
 209   def P9_DP_5C : SchedWriteRes<[DP]> {
 210     let Latency = 5;
 211   }
 212
 213   def P9_DP_7C : SchedWriteRes<[DP]> {
 214     let Latency = 7;
 215   }
 216
 217   def P9_DPE_7C : SchedWriteRes<[DPE]> {
 218     let Latency = 7;
 219   }
 220
 221   def P9_DPO_7C : SchedWriteRes<[DPO]> {
 222     let Latency = 7;
 223   }
 224
 225   def P9_DP_22C_5 : SchedWriteRes<[DP]> {
 226     let ResourceCycles = [5];
 227     let Latency = 22;
 228   }
 229
 230   def P9_DP_24C_8 : SchedWriteRes<[DP]> {
 231     let ResourceCycles = [8];
 232     let Latency = 24;
 233   }
 234
 235   def P9_DPO_24C_8 : SchedWriteRes<[DPO]> {
 236     let ResourceCycles = [8];
 237     let Latency = 24;
 238   }
 239
 240   def P9_DPE_24C_8 : SchedWriteRes<[DPE]> {
 241     let ResourceCycles = [8];
 242     let Latency = 24;
 243   }
 244
 245   def P9_DP_26C_5 : SchedWriteRes<[DP]> {
 246     let ResourceCycles = [5];
 247     let Latency = 22;
 248   }
 249
 250   def P9_DP_27C_7 : SchedWriteRes<[DP]> {
 251     let ResourceCycles = [7];
 252     let Latency = 27;
 253   }
 254
 255   def P9_DPE_27C_10 : SchedWriteRes<[DP]> {
 256     let ResourceCycles = [10];
 257     let Latency = 27;
 258   }
 259
 260   def P9_DPO_27C_10 : SchedWriteRes<[DP]> {
 261     let ResourceCycles = [10];
 262     let Latency = 27;
 263   }
 264
 265   def P9_DP_33C_8 : SchedWriteRes<[DP]> {
 266     let ResourceCycles = [8];
 267     let Latency = 33;
 268   }
 269
 270   def P9_DPE_33C_8 : SchedWriteRes<[DPE]> {
 271     let ResourceCycles = [8];
 272     let Latency = 33;
 273   }
 274
 275   def P9_DPO_33C_8 : SchedWriteRes<[DPO]> {
 276     let ResourceCycles = [8];
 277     let Latency = 33;
 278   }
 279
 280   def P9_DP_36C_10 : SchedWriteRes<[DP]> {
 281     let ResourceCycles = [10];
 282     let Latency = 36;
 283   }
 284
 285   def P9_DPE_36C_10 : SchedWriteRes<[DP]> {
 286     let ResourceCycles = [10];
 287     let Latency = 36;
 288   }
 289
 290   def P9_DPO_36C_10 : SchedWriteRes<[DP]> {
 291     let ResourceCycles = [10];
 292     let Latency = 36;
 293   }
 294
 295   // PM Unit
 296   // Three cycle permute operations.
 297   def P9_PM_3C : SchedWriteRes<[PM]> {
 298     let Latency = 3;
 299   }
 300
 301   // Load and Store Units
 302   // Loads can have 4, 5 or 6 cycles of latency.
 303   // Stores are listed as having a single cycle of latency. This is not
 304   // completely accurate since it takes more than 1 cycle to actually store
 305   // the value. However, since the store does not produce a result it can be
 306   // considered complete after one cycle.
 307   def P9_LS_1C : SchedWriteRes<[LS]> {
 308     let Latency = 1;
 309   }
 310
 311   def P9_LS_4C : SchedWriteRes<[LS]> {
 312     let Latency = 4;
 313   }
 314
 315   def P9_LS_5C : SchedWriteRes<[LS]> {
 316     let Latency = 5;
 317   }
 318
 319   def P9_LS_6C : SchedWriteRes<[LS]> {
 320     let Latency = 6;
 321   }
 322
 323   // DFU Unit
 324   // Some of the most expensive ops use the DFU.
 325   // Can take from 12 cycles to 76 cycles to obtain a result.
 326   // The unit may be busy for up to 62 cycles.
 327   def P9_DFU_12C : SchedWriteRes<[DFU]> {
 328     let Latency = 12;
 329   }
 330
 331   def P9_DFU_23C : SchedWriteRes<[DFU]> {
 332     let Latency = 23;
 333     let ResourceCycles = [11];
 334   }
 335
 336   def P9_DFU_24C : SchedWriteRes<[DFU]> {
 337     let Latency = 24;
 338     let ResourceCycles = [12];
 339   }
 340
 341   def P9_DFU_37C : SchedWriteRes<[DFU]> {
 342     let Latency = 37;
 343     let ResourceCycles = [25];
 344   }
 345
 346   def P9_DFU_58C : SchedWriteRes<[DFU]> {
 347     let Latency = 58;
 348     let ResourceCycles = [44];
 349   }
 350
 351   def P9_DFU_76C : SchedWriteRes<[DFU]> {
 352     let Latency = 76;
 353     let ResourceCycles = [62];
 354   }
 355
 356   // 2 or 5 cycle latencies for the branch unit.
 357   def P9_BR_2C : SchedWriteRes<[BR]> {
 358     let Latency = 2;
 359   }
 360
 361   def P9_BR_5C : SchedWriteRes<[BR]> {
 362     let Latency = 5;
 363   }
 364
 365   // 6 cycle latency for the crypto unit
 366   def P9_CY_6C : SchedWriteRes<[CY]> {
 367     let Latency = 6;
 368   }
 369
 370   // ***************** WriteSeq Definitions *****************
 371
 372   // These are combinations of the resources listed above.
 373   // The idea is that some cracked instructions cannot be done in parallel and
 374   // so the latencies for their resources must be added.
 375   def P9_LoadAndALUOp_6C : WriteSequence<[P9_LS_4C, P9_ALU_2C]>;
 376   def P9_LoadAndALUOp_7C : WriteSequence<[P9_LS_5C, P9_ALU_2C]>;
 377   def P9_LoadAndALU2Op_7C : WriteSequence<[P9_LS_4C, P9_ALU_3C]>;
 378   def P9_LoadAndALU2Op_8C : WriteSequence<[P9_LS_5C, P9_ALU_3C]>;
 379   def P9_LoadAndPMOp_8C : WriteSequence<[P9_LS_5C, P9_PM_3C]>;
 380   def P9_LoadAndLoadOp_8C : WriteSequence<[P9_LS_4C, P9_LS_4C]>;
 381   def P9_IntDivAndALUOp_18C_8 : WriteSequence<[P9_DIV_16C_8, P9_ALU_2C]>;
 382   def P9_IntDivAndALUOp_26C_8 : WriteSequence<[P9_DIV_24C_8, P9_ALU_2C]>;
 383   def P9_IntDivAndALUOp_42C_8 : WriteSequence<[P9_DIV_40C_8, P9_ALU_2C]>;
 384   def P9_StoreAndALUOp_3C : WriteSequence<[P9_LS_1C, P9_ALU_2C]>;
 385   def P9_StoreAndALUOp_4C : WriteSequence<[P9_LS_1C, P9_ALU_3C]>;
 386   def P9_ALUOpAndALUOp_4C : WriteSequence<[P9_ALU_2C, P9_ALU_2C]>;
 387   def P9_ALU2OpAndALU2Op_6C : WriteSequence<[P9_ALU_3C, P9_ALU_3C]>;
 388   def P9_ALUOpAndALUOpAndALUOp_6C :
 389     WriteSequence<[P9_ALU_2C, P9_ALU_2C, P9_ALU_2C]>;
 390   def P9_DPOpAndALUOp_7C : WriteSequence<[P9_DP_5C, P9_ALU_2C]>;
 391   def P9_DPOpAndALUOp_9C : WriteSequence<[P9_DP_7C, P9_ALU_2C]>;
 392   def P9_DPOpAndALU2Op_10C : WriteSequence<[P9_DP_7C, P9_ALU_3C]>;
 393   def P9_DPOpAndALUOp_24C_5 : WriteSequence<[P9_DP_22C_5, P9_ALU_2C]>;
 394   def P9_DPOpAndALUOp_35C_8 : WriteSequence<[P9_DP_33C_8, P9_ALU_2C]>;
 395   def P9_DPOpAndALU2Op_25C_5 : WriteSequence<[P9_DP_22C_5, P9_ALU_3C]>;
 396   def P9_DPOpAndALU2Op_29C_5 : WriteSequence<[P9_DP_26C_5, P9_ALU_3C]>;
 397   def P9_DPOpAndALU2Op_36C_8 : WriteSequence<[P9_DP_33C_8, P9_ALU_3C]>;
 398   def P9_DPOpAndALU2Op_39C_10 : WriteSequence<[P9_DP_36C_10, P9_ALU_3C]>;
 399   def P9_BROpAndALUOp_7C : WriteSequence<[P9_BR_5C, P9_ALU_2C]>;
 400
 401   // Include the resource requirements of individual instructions.
 402   include "P9InstrResources.td"
 403
 404 }
 405