1 //==- AArch64SchedKryo.td - Qualcomm Kryo Scheduling Defs ---*- tablegen -*-==// 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 // This file defines the machine model for Qualcomm Kryo to support 11 // instruction scheduling and other instruction cost heuristics. 12 // 13 //===----------------------------------------------------------------------===// 14 15 //===----------------------------------------------------------------------===// 16 // The issue width is set to five, matching the five issue queues for expanded 17 // uops. Now, the latency spreadsheet has information based on fragmented uops, 18 // but these do not actually take up an issue queue. 19 20 def KryoModel : SchedMachineModel { 21 let IssueWidth = 5; // 5-wide issue for expanded uops 22 let MicroOpBufferSize = 128; // Out-of-order with temporary unified issue buffer 23 let LoadLatency = 4; // Optimistic load latency 24 let MispredictPenalty = 14; // Fetch + Decode/Rename/Dispatch + Branch 25 26 // Enable partial & runtime unrolling. The magic number is chosen based on 27 // experiments and benchmarking data. 28 let LoopMicroOpBufferSize = 16; 29 let CompleteModel = 1; 30 31 list<Predicate> UnsupportedFeatures = [HasSVE]; 32 33 // FIXME: Remove when all errors have been fixed. 34 let FullInstRWOverlapCheck = 0; 35 } 36 37 //===----------------------------------------------------------------------===// 38 // Define each kind of processor resource and number available on Kryo. 39 40 let SchedModel = KryoModel in { 41 def KryoUnitXA : ProcResource<1>; // Type X(A) micro-ops 42 def KryoUnitXB : ProcResource<1>; // Type X(B) micro-ops 43 def KryoUnitYA : ProcResource<1>; // Type Y(A) micro-ops 44 def KryoUnitYB : ProcResource<1>; // Type Y(B) micro-ops 45 def KryoUnitX : ProcResGroup<[KryoUnitXA, // Type X micro-ops 46 KryoUnitXB]>; 47 def KryoUnitY : ProcResGroup<[KryoUnitYA, // Type Y micro-ops 48 KryoUnitYB]>; 49 def KryoUnitXY : ProcResGroup<[KryoUnitXA, // Type XY micro-ops 50 KryoUnitXB, 51 KryoUnitYA, 52 KryoUnitYB]>; 53 def KryoUnitLSA : ProcResource<1>; // Type LS(A) micro-ops 54 def KryoUnitLSB : ProcResource<1>; // Type LS(B) micro-ops 55 def KryoUnitLS : ProcResGroup<[KryoUnitLSA, // Type LS micro-ops 56 KryoUnitLSB]>; 57 } 58 59 let SchedModel = KryoModel in { 60 61 //===----------------------------------------------------------------------===// 62 // Map the target-defined scheduler read/write resources and latency for 63 // Kryo. 64 65 def : WriteRes<WriteImm, [KryoUnitXY]> { let Latency = 1; } 66 def : WriteRes<WriteI, [KryoUnitXY]> { let Latency = 1; } 67 def : WriteRes<WriteISReg, [KryoUnitXY, KryoUnitXY]> 68 { let Latency = 2; let NumMicroOps = 2; } 69 def : WriteRes<WriteIEReg, [KryoUnitXY, KryoUnitXY]> 70 { let Latency = 2; let NumMicroOps = 2; } 71 def : WriteRes<WriteExtr, [KryoUnitXY, KryoUnitX]> 72 { let Latency = 2; let NumMicroOps = 2; } 73 def : WriteRes<WriteIS, [KryoUnitXY]> { let Latency = 2; } 74 def : WriteRes<WriteID32, [KryoUnitXA, KryoUnitY]> 75 { let Latency = 8; let NumMicroOps = 1; } // Fragent -1 76 def : WriteRes<WriteID64, [KryoUnitXA, KryoUnitY]> 77 { let Latency = 8; let NumMicroOps = 1; } // Fragent -1 78 def : WriteRes<WriteIM32, [KryoUnitX]> { let Latency = 5; } 79 def : WriteRes<WriteIM64, [KryoUnitX]> { let Latency = 5; } 80 def : WriteRes<WriteBr, [KryoUnitXY]> { let Latency = 1; } 81 def : WriteRes<WriteBrReg, [KryoUnitXY]> { let Latency = 1; } 82 def : WriteRes<WriteLD, [KryoUnitLS]> { let Latency = 4; } 83 def : WriteRes<WriteST, [KryoUnitLS]> { let Latency = 4; } 84 def : WriteRes<WriteSTP, [KryoUnitLS]> { let Latency = 4; } 85 def : WriteRes<WriteAdr, [KryoUnitXY]> { let Latency = 6; } 86 def : WriteRes<WriteLDIdx, [KryoUnitLS]> { let Latency = 4; } 87 def : WriteRes<WriteSTIdx, [KryoUnitLS]> { let Latency = 4; } 88 def : WriteRes<WriteF, [KryoUnitXY, KryoUnitXY]> 89 { let Latency = 3; let NumMicroOps = 2; } 90 def : WriteRes<WriteFCmp, [KryoUnitXY]> { let Latency = 2; } 91 def : WriteRes<WriteFCvt, [KryoUnitX]> { let Latency = 4; } 92 def : WriteRes<WriteFCopy, [KryoUnitXY]> { let Latency = 6; } 93 def : WriteRes<WriteFImm, [KryoUnitXY]> { let Latency = 6; } 94 def : WriteRes<WriteFMul, [KryoUnitX, KryoUnitX]> 95 { let Latency = 6; let NumMicroOps = 2; } 96 def : WriteRes<WriteFDiv, [KryoUnitXA, KryoUnitY]> 97 { let Latency = 12; let NumMicroOps = 2; } // Fragent -1 / NoRSV +1 98 def : WriteRes<WriteV, [KryoUnitXY]> { let Latency = 6; } 99 def : WriteRes<WriteVLD, [KryoUnitLS]> { let Latency = 4; } 100 def : WriteRes<WriteVST, [KryoUnitLS]> { let Latency = 4; } 101 102 def : WriteRes<WriteSys, []> { let Latency = 1; } 103 def : WriteRes<WriteBarrier, []> { let Latency = 1; } 104 def : WriteRes<WriteHint, []> { let Latency = 1; } 105 106 def : WriteRes<WriteLDHi, []> { let Latency = 4; } 107 108 def : WriteRes<WriteAtomic, []> { let Unsupported = 1; } 109 110 // No forwarding logic is modelled yet. 111 def : ReadAdvance<ReadI, 0>; 112 def : ReadAdvance<ReadISReg, 0>; 113 def : ReadAdvance<ReadIEReg, 0>; 114 def : ReadAdvance<ReadIM, 0>; 115 def : ReadAdvance<ReadIMA, 0>; 116 def : ReadAdvance<ReadID, 0>; 117 def : ReadAdvance<ReadExtrHi, 0>; 118 def : ReadAdvance<ReadAdrBase, 0>; 119 def : ReadAdvance<ReadVLD, 0>; 120 121 122 //===----------------------------------------------------------------------===// 123 // Specialize the coarse model by associating instruction groups with the 124 // subtarget-defined types. As the modeled is refined, this will override most 125 // of the above SchedWriteRes and SchedAlias mappings. 126 127 // Miscellaneous 128 // ----------------------------------------------------------------------------- 129 130 def : InstRW<[WriteI], (instrs COPY)>; 131 132 133 // Detailed Refinedments 134 // ----------------------------------------------------------------------------- 135 include "AArch64SchedKryoDetails.td" 136 137 138 } // SchedModel = KryoModel 139
