1package xiangshan.backend.issue 2 3import org.chipsalliance.cde.config.Parameters 4import chisel3._ 5import chisel3.util._ 6import freechips.rocketchip.diplomacy.{LazyModule, LazyModuleImp} 7import utility.{GTimer, HasCircularQueuePtrHelper, SelectOne} 8import utils._ 9import xiangshan._ 10import xiangshan.backend.Bundles._ 11import xiangshan.backend.issue.EntryBundles._ 12import xiangshan.backend.decode.{ImmUnion, Imm_LUI_LOAD} 13import xiangshan.backend.datapath.DataConfig._ 14import xiangshan.backend.datapath.DataSource 15import xiangshan.backend.fu.{FuConfig, FuType} 16import xiangshan.mem.{MemWaitUpdateReq, SqPtr, LqPtr} 17import xiangshan.backend.rob.RobPtr 18import xiangshan.backend.datapath.NewPipelineConnect 19 20class IssueQueue(params: IssueBlockParams)(implicit p: Parameters) extends LazyModule with HasXSParameter { 21 override def shouldBeInlined: Boolean = false 22 23 implicit val iqParams = params 24 lazy val module: IssueQueueImp = iqParams.schdType match { 25 case IntScheduler() => new IssueQueueIntImp(this) 26 case VfScheduler() => new IssueQueueVfImp(this) 27 case MemScheduler() => 28 if (iqParams.StdCnt == 0 && !iqParams.isVecMemIQ) new IssueQueueMemAddrImp(this) 29 else if (iqParams.isVecMemIQ) new IssueQueueVecMemImp(this) 30 else new IssueQueueIntImp(this) 31 case _ => null 32 } 33} 34 35class IssueQueueStatusBundle(numEnq: Int, numEntries: Int) extends Bundle { 36 val empty = Output(Bool()) 37 val full = Output(Bool()) 38 val validCnt = Output(UInt(log2Ceil(numEntries).W)) 39 val leftVec = Output(Vec(numEnq + 1, Bool())) 40} 41 42class IssueQueueDeqRespBundle(implicit p:Parameters, params: IssueBlockParams) extends EntryDeqRespBundle 43 44class IssueQueueIO()(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 45 // Inputs 46 val flush = Flipped(ValidIO(new Redirect)) 47 val enq = Vec(params.numEnq, Flipped(DecoupledIO(new DynInst))) 48 49 val og0Resp = Vec(params.numDeq, Flipped(ValidIO(new IssueQueueDeqRespBundle))) 50 val og1Resp = Vec(params.numDeq, Flipped(ValidIO(new IssueQueueDeqRespBundle))) 51 val finalIssueResp = OptionWrapper(params.LdExuCnt > 0, Vec(params.numDeq, Flipped(ValidIO(new IssueQueueDeqRespBundle)))) 52 val memAddrIssueResp = OptionWrapper(params.LdExuCnt > 0, Vec(params.numDeq, Flipped(ValidIO(new IssueQueueDeqRespBundle)))) 53 val wbBusyTableRead = Input(params.genWbFuBusyTableReadBundle()) 54 val wbBusyTableWrite = Output(params.genWbFuBusyTableWriteBundle()) 55 val wakeupFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle) 56 val wakeupFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle) 57 val og0Cancel = Input(ExuOH(backendParams.numExu)) 58 val og1Cancel = Input(ExuOH(backendParams.numExu)) 59 val ldCancel = Vec(backendParams.LduCnt + backendParams.HyuCnt, Flipped(new LoadCancelIO)) 60 61 // Outputs 62 val wakeupToIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = params.genIQWakeUpSourceValidBundle 63 val status = Output(new IssueQueueStatusBundle(params.numEnq, params.numEntries)) 64 val validCntDeqVec = Output(Vec(params.numDeq,UInt(params.numEntries.U.getWidth.W))) 65 // val statusNext = Output(new IssueQueueStatusBundle(params.numEnq)) 66 67 val deqDelay: MixedVec[DecoupledIO[IssueQueueIssueBundle]] = params.genIssueDecoupledBundle// = deq.cloneType 68 def allWakeUp = wakeupFromWB ++ wakeupFromIQ 69} 70 71class IssueQueueImp(override val wrapper: IssueQueue)(implicit p: Parameters, val params: IssueBlockParams) 72 extends LazyModuleImp(wrapper) 73 with HasXSParameter { 74 75 override def desiredName: String = s"${params.getIQName}" 76 77 println(s"[IssueQueueImp] ${params.getIQName} wakeupFromWB(${io.wakeupFromWB.size}), " + 78 s"wakeup exu in(${params.wakeUpInExuSources.size}): ${params.wakeUpInExuSources.map(_.name).mkString("{",",","}")}, " + 79 s"wakeup exu out(${params.wakeUpOutExuSources.size}): ${params.wakeUpOutExuSources.map(_.name).mkString("{",",","}")}, " + 80 s"numEntries: ${params.numEntries}, numRegSrc: ${params.numRegSrc}, " + 81 s"numEnq: ${params.numEnq}, numSimp: ${params.numSimp}, numComp: ${params.numComp}, numDeq: ${params.numDeq}, " + 82 s"isAllSimp: ${params.isAllSimp}, isAllComp: ${params.isAllComp}") 83 84 require(params.numExu <= 2, "IssueQueue has not supported more than 2 deq ports") 85 require(params.numEnq <= 2, "IssueQueue has not supported more than 2 enq ports") 86 require(params.numSimp == 0 || params.numSimp >= params.numEnq, "numSimp should be 0 or at least not less than numEnq") 87 require(params.numComp == 0 || params.numComp >= params.numEnq, "numComp should be 0 or at least not less than numEnq") 88 89 val deqFuCfgs : Seq[Seq[FuConfig]] = params.exuBlockParams.map(_.fuConfigs) 90 val allDeqFuCfgs : Seq[FuConfig] = params.exuBlockParams.flatMap(_.fuConfigs) 91 val fuCfgsCnt : Map[FuConfig, Int] = allDeqFuCfgs.groupBy(x => x).map { case (cfg, cfgSeq) => (cfg, cfgSeq.length) } 92 val commonFuCfgs : Seq[FuConfig] = fuCfgsCnt.filter(_._2 > 1).keys.toSeq 93 val fuLatencyMaps : Seq[Map[FuType.OHType, Int]] = params.exuBlockParams.map(x => x.fuLatencyMap) 94 95 println(s"[IssueQueueImp] ${params.getIQName} fuLatencyMaps: ${fuLatencyMaps}") 96 println(s"[IssueQueueImp] ${params.getIQName} commonFuCfgs: ${commonFuCfgs.map(_.name)}") 97 lazy val io = IO(new IssueQueueIO()) 98 99 // Modules 100 val entries = Module(new Entries) 101 val fuBusyTableWrite = params.exuBlockParams.map { case x => OptionWrapper(x.latencyValMax > 0, Module(new FuBusyTableWrite(x.fuLatencyMap))) } 102 val fuBusyTableRead = params.exuBlockParams.map { case x => OptionWrapper(x.latencyValMax > 0, Module(new FuBusyTableRead(x.fuLatencyMap))) } 103 val intWbBusyTableWrite = params.exuBlockParams.map { case x => OptionWrapper(x.intLatencyCertain, Module(new FuBusyTableWrite(x.intFuLatencyMap))) } 104 val intWbBusyTableRead = params.exuBlockParams.map { case x => OptionWrapper(x.intLatencyCertain, Module(new FuBusyTableRead(x.intFuLatencyMap))) } 105 val vfWbBusyTableWrite = params.exuBlockParams.map { case x => OptionWrapper(x.vfLatencyCertain, Module(new FuBusyTableWrite(x.vfFuLatencyMap))) } 106 val vfWbBusyTableRead = params.exuBlockParams.map { case x => OptionWrapper(x.vfLatencyCertain, Module(new FuBusyTableRead(x.vfFuLatencyMap))) } 107 108 class WakeupQueueFlush extends Bundle { 109 val redirect = ValidIO(new Redirect) 110 val ldCancel = Vec(backendParams.LduCnt + backendParams.HyuCnt, new LoadCancelIO) 111 val og0Fail = Output(Bool()) 112 val og1Fail = Output(Bool()) 113 } 114 115 private def flushFunc(exuInput: ExuInput, flush: WakeupQueueFlush, stage: Int): Bool = { 116 val redirectFlush = exuInput.robIdx.needFlush(flush.redirect) 117 val loadDependencyFlush = LoadShouldCancel(exuInput.loadDependency, flush.ldCancel) 118 val ogFailFlush = stage match { 119 case 1 => flush.og0Fail 120 case 2 => flush.og1Fail 121 case _ => false.B 122 } 123 redirectFlush || loadDependencyFlush || ogFailFlush 124 } 125 126 private def modificationFunc(exuInput: ExuInput): ExuInput = { 127 val newExuInput = WireDefault(exuInput) 128 newExuInput.loadDependency match { 129 case Some(deps) => deps.zip(exuInput.loadDependency.get).foreach(x => x._1 := x._2 << 1) 130 case None => 131 } 132 newExuInput 133 } 134 135 private def lastConnectFunc(exuInput: ExuInput, newInput: ExuInput): ExuInput = { 136 val lastExuInput = WireDefault(exuInput) 137 val newExuInput = WireDefault(newInput) 138 newExuInput.elements.foreach { case (name, data) => 139 if (lastExuInput.elements.contains(name)) { 140 data := lastExuInput.elements(name) 141 } 142 } 143 if (newExuInput.pdestCopy.nonEmpty && !lastExuInput.pdestCopy.nonEmpty) { 144 newExuInput.pdestCopy.get.foreach(_ := lastExuInput.pdest) 145 } 146 if (newExuInput.rfWenCopy.nonEmpty && !lastExuInput.rfWenCopy.nonEmpty) { 147 newExuInput.rfWenCopy.get.foreach(_ := lastExuInput.rfWen.get) 148 } 149 if (newExuInput.fpWenCopy.nonEmpty && !lastExuInput.fpWenCopy.nonEmpty) { 150 newExuInput.fpWenCopy.get.foreach(_ := lastExuInput.fpWen.get) 151 } 152 if (newExuInput.vecWenCopy.nonEmpty && !lastExuInput.vecWenCopy.nonEmpty) { 153 newExuInput.vecWenCopy.get.foreach(_ := lastExuInput.rfWen.get) 154 } 155 if (newExuInput.loadDependencyCopy.nonEmpty && !lastExuInput.loadDependencyCopy.nonEmpty) { 156 newExuInput.loadDependencyCopy.get.foreach(_ := lastExuInput.loadDependency.get) 157 } 158 newExuInput 159 } 160 161 val wakeUpQueues: Seq[Option[MultiWakeupQueue[ExuInput, WakeupQueueFlush]]] = params.exuBlockParams.map { x => OptionWrapper(x.isIQWakeUpSource && !x.hasLoadExu, Module( 162 new MultiWakeupQueue(new ExuInput(x), new ExuInput(x, x.copyWakeupOut, x.copyNum), new WakeupQueueFlush, x.wakeUpFuLatancySet, flushFunc, modificationFunc, lastConnectFunc) 163 ))} 164 val deqBeforeDly = Wire(params.genIssueDecoupledBundle) 165 166 val intWbBusyTableIn = io.wbBusyTableRead.map(_.intWbBusyTable) 167 val vfWbBusyTableIn = io.wbBusyTableRead.map(_.vfWbBusyTable) 168 val intWbBusyTableOut = io.wbBusyTableWrite.map(_.intWbBusyTable) 169 val vfWbBusyTableOut = io.wbBusyTableWrite.map(_.vfWbBusyTable) 170 val intDeqRespSetOut = io.wbBusyTableWrite.map(_.intDeqRespSet) 171 val vfDeqRespSetOut = io.wbBusyTableWrite.map(_.vfDeqRespSet) 172 val fuBusyTableMask = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 173 val intWbBusyTableMask = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 174 val vfWbBusyTableMask = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 175 val s0_enqValidVec = io.enq.map(_.valid) 176 val s0_enqSelValidVec = Wire(Vec(params.numEnq, Bool())) 177 val s0_enqNotFlush = !io.flush.valid 178 val s0_enqBits = WireInit(VecInit(io.enq.map(_.bits))) 179 val s0_doEnqSelValidVec = s0_enqSelValidVec.map(_ && s0_enqNotFlush) //enqValid && notFlush && enqReady 180 181 182 val finalDeqSelValidVec = Wire(Vec(params.numDeq, Bool())) 183 val finalDeqSelOHVec = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 184 185 val validVec = VecInit(entries.io.valid.asBools) 186 val canIssueVec = VecInit(entries.io.canIssue.asBools) 187 dontTouch(canIssueVec) 188 val deqFirstIssueVec = entries.io.isFirstIssue 189 190 val dataSources: Vec[Vec[DataSource]] = entries.io.dataSources 191 val finalDataSources: Vec[Vec[DataSource]] = VecInit(finalDeqSelOHVec.map(oh => Mux1H(oh, dataSources))) 192 val loadDependency: Vec[Vec[UInt]] = entries.io.loadDependency 193 val finalLoadDependency: IndexedSeq[Vec[UInt]] = VecInit(finalDeqSelOHVec.map(oh => Mux1H(oh, loadDependency))) 194 // (entryIdx)(srcIdx)(exuIdx) 195 val wakeUpL1ExuOH: Option[Vec[Vec[UInt]]] = entries.io.srcWakeUpL1ExuOH 196 val srcTimer: Option[Vec[Vec[UInt]]] = entries.io.srcTimer 197 198 // (deqIdx)(srcIdx)(exuIdx) 199 val finalWakeUpL1ExuOH: Option[Vec[Vec[UInt]]] = wakeUpL1ExuOH.map(x => VecInit(finalDeqSelOHVec.map(oh => Mux1H(oh, x)))) 200 val finalSrcTimer = srcTimer.map(x => VecInit(finalDeqSelOHVec.map(oh => Mux1H(oh, x)))) 201 202 val fuTypeVec = Wire(Vec(params.numEntries, FuType())) 203 val deqEntryVec = Wire(Vec(params.numDeq, ValidIO(new EntryBundle))) 204 val canIssueMergeAllBusy = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 205 val deqCanIssue = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 206 207 //deq 208 val enqEntryOldestSel = Wire(Vec(params.numDeq, ValidIO(UInt(params.numEnq.W)))) 209 val simpEntryOldestSel = OptionWrapper(params.hasCompAndSimp, Wire(Vec(params.numDeq + params.numEnq, ValidIO(UInt(params.numSimp.W))))) 210 val compEntryOldestSel = OptionWrapper(params.hasCompAndSimp, Wire(Vec(params.numDeq, ValidIO(UInt(params.numComp.W))))) 211 val othersEntryOldestSel = Wire(Vec(params.numDeq, ValidIO(UInt((params.numEntries - params.numEnq).W)))) 212 val deqSelValidVec = Wire(Vec(params.numDeq, Bool())) 213 val deqSelOHVec = Wire(Vec(params.numDeq, UInt(params.numEntries.W))) 214 val cancelDeqVec = Wire(Vec(params.numDeq, Bool())) 215 216 val subDeqSelValidVec = OptionWrapper(params.deqFuSame, Wire(Vec(params.numDeq, Bool()))) 217 val subDeqSelOHVec = OptionWrapper(params.deqFuSame, Wire(Vec(params.numDeq, UInt(params.numEntries.W)))) 218 val subDeqRequest = OptionWrapper(params.deqFuSame, Wire(UInt(params.numEntries.W))) 219 220 //trans 221 val simpEntryEnqSelVec = OptionWrapper(params.hasCompAndSimp, Wire(Vec(params.numEnq, UInt(params.numSimp.W)))) 222 val compEntryEnqSelVec = OptionWrapper(params.hasCompAndSimp, Wire(Vec(params.numEnq, UInt(params.numComp.W)))) 223 val othersEntryEnqSelVec = OptionWrapper(params.isAllComp || params.isAllSimp, Wire(Vec(params.numEnq, UInt((params.numEntries - params.numEnq).W)))) 224 val simpAgeDetectRequest = OptionWrapper(params.hasCompAndSimp, Wire(Vec(params.numDeq + params.numEnq, UInt(params.numSimp.W)))) 225 simpAgeDetectRequest.foreach(_ := 0.U.asTypeOf(simpAgeDetectRequest.get)) 226 227 /** 228 * Connection of [[entries]] 229 */ 230 entries.io match { case entriesIO: EntriesIO => 231 entriesIO.flush := io.flush 232 entriesIO.enq.zipWithIndex.foreach { case (enq, enqIdx) => 233 enq.valid := s0_doEnqSelValidVec(enqIdx) 234 enq.bits.status.robIdx := s0_enqBits(enqIdx).robIdx 235 enq.bits.status.fuType := IQFuType.readFuType(VecInit(s0_enqBits(enqIdx).fuType.asBools), params.getFuCfgs.map(_.fuType)) 236 val numLsrc = s0_enqBits(enqIdx).srcType.size.min(enq.bits.status.srcStatus.map(_.srcType).size) 237 for(j <- 0 until numLsrc) { 238 enq.bits.status.srcStatus(j).psrc := s0_enqBits(enqIdx).psrc(j) 239 enq.bits.status.srcStatus(j).srcType := s0_enqBits(enqIdx).srcType(j) 240 enq.bits.status.srcStatus(j).srcState := s0_enqBits(enqIdx).srcState(j) & !LoadShouldCancel(Some(s0_enqBits(enqIdx).srcLoadDependency(j)), io.ldCancel) 241 enq.bits.status.srcStatus(j).dataSources.value := Mux( 242 SrcType.isXp(s0_enqBits(enqIdx).srcType(j)) && (s0_enqBits(enqIdx).psrc(j) === 0.U), 243 DataSource.zero, 244 Mux(SrcType.isNotReg(s0_enqBits(enqIdx).srcType(j)), DataSource.imm, DataSource.reg) 245 ) 246 enq.bits.status.srcStatus(j).srcLoadDependency := VecInit(s0_enqBits(enqIdx).srcLoadDependency(j).map(x => x(x.getWidth - 2, 0) << 1)) 247 if(params.hasIQWakeUp) { 248 enq.bits.status.srcStatus(j).srcTimer.get := 0.U(3.W) 249 enq.bits.status.srcStatus(j).srcWakeUpL1ExuOH.get := 0.U.asTypeOf(ExuVec()) 250 } 251 } 252 enq.bits.status.blocked := false.B 253 enq.bits.status.issued := false.B 254 enq.bits.status.firstIssue := false.B 255 enq.bits.status.issueTimer := "b10".U 256 enq.bits.status.deqPortIdx := 0.U 257 if (params.isVecMemIQ) { 258 enq.bits.status.vecMem.get.uopIdx := s0_enqBits(enqIdx).uopIdx 259 } 260 if (params.inIntSchd && params.AluCnt > 0) { 261 // dirty code for lui+addi(w) fusion 262 val isLuiAddiFusion = s0_enqBits(enqIdx).isLUI32 263 val luiImm = Cat(s0_enqBits(enqIdx).lsrc(1), s0_enqBits(enqIdx).lsrc(0), s0_enqBits(enqIdx).imm(ImmUnion.maxLen - 1, 0)) 264 enq.bits.imm.foreach(_ := Mux(isLuiAddiFusion, ImmUnion.LUI32.toImm32(luiImm), s0_enqBits(enqIdx).imm)) 265 } 266 else if (params.inMemSchd && params.LduCnt > 0) { 267 // dirty code for fused_lui_load 268 val isLuiLoadFusion = SrcType.isNotReg(s0_enqBits(enqIdx).srcType(0)) && FuType.isLoad(s0_enqBits(enqIdx).fuType) 269 enq.bits.imm.foreach(_ := Mux(isLuiLoadFusion, Imm_LUI_LOAD().getLuiImm(s0_enqBits(enqIdx)), s0_enqBits(enqIdx).imm)) 270 } 271 else { 272 enq.bits.imm.foreach(_ := s0_enqBits(enqIdx).imm) 273 } 274 enq.bits.payload := s0_enqBits(enqIdx) 275 } 276 entriesIO.og0Resp.zipWithIndex.foreach { case (og0Resp, i) => 277 og0Resp := io.og0Resp(i) 278 } 279 entriesIO.og1Resp.zipWithIndex.foreach { case (og1Resp, i) => 280 og1Resp := io.og1Resp(i) 281 } 282 entriesIO.finalIssueResp.foreach(_.zipWithIndex.foreach { case (finalIssueResp, i) => 283 finalIssueResp := io.finalIssueResp.get(i) 284 }) 285 entriesIO.memAddrIssueResp.foreach(_. zipWithIndex.foreach { case (memAddrIssueResp, i) => 286 memAddrIssueResp := io.memAddrIssueResp.get(i) 287 }) 288 for(deqIdx <- 0 until params.numDeq) { 289 entriesIO.deqReady(deqIdx) := deqBeforeDly(deqIdx).ready 290 entriesIO.deqSelOH(deqIdx).valid := deqSelValidVec(deqIdx) 291 entriesIO.deqSelOH(deqIdx).bits := deqSelOHVec(deqIdx) 292 entriesIO.enqEntryOldestSel(deqIdx) := enqEntryOldestSel(deqIdx) 293 entriesIO.simpEntryOldestSel.foreach(_(deqIdx) := simpEntryOldestSel.get(deqIdx)) 294 entriesIO.compEntryOldestSel.foreach(_(deqIdx) := compEntryOldestSel.get(deqIdx)) 295 entriesIO.othersEntryOldestSel.foreach(_(deqIdx) := othersEntryOldestSel(deqIdx)) 296 entriesIO.subDeqRequest.foreach(_(deqIdx) := subDeqRequest.get) 297 entriesIO.subDeqSelOH.foreach(_(deqIdx) := subDeqSelOHVec.get(deqIdx)) 298 } 299 entriesIO.wakeUpFromWB := io.wakeupFromWB 300 entriesIO.wakeUpFromIQ := io.wakeupFromIQ 301 entriesIO.og0Cancel := io.og0Cancel 302 entriesIO.og1Cancel := io.og1Cancel 303 entriesIO.ldCancel := io.ldCancel 304 entriesIO.simpEntryDeqSelVec.foreach(_ := VecInit(simpEntryOldestSel.get.takeRight(params.numEnq).map(_.bits))) 305 //output 306 fuTypeVec := entriesIO.fuType 307 deqEntryVec := entriesIO.deqEntry 308 cancelDeqVec := entriesIO.cancelDeqVec 309 simpEntryEnqSelVec.foreach(_ := entriesIO.simpEntryEnqSelVec.get) 310 compEntryEnqSelVec.foreach(_ := entriesIO.compEntryEnqSelVec.get) 311 othersEntryEnqSelVec.foreach(_ := entriesIO.othersEntryEnqSelVec.get) 312 } 313 314 315 s0_enqSelValidVec := s0_enqValidVec.zip(io.enq).map{ case (enqValid, enq) => enqValid && enq.ready} 316 317 protected val commonAccept: UInt = Cat(fuTypeVec.map(fuType => 318 FuType.FuTypeOrR(fuType, commonFuCfgs.map(_.fuType)) 319 ).reverse) 320 321 // if deq port can accept the uop 322 protected val canAcceptVec: Seq[UInt] = deqFuCfgs.map { fuCfgs: Seq[FuConfig] => 323 Cat(fuTypeVec.map(fuType => 324 FuType.FuTypeOrR(fuType, fuCfgs.map(_.fuType)) 325 ).reverse) 326 } 327 328 protected val deqCanAcceptVec: Seq[IndexedSeq[Bool]] = deqFuCfgs.map { fuCfgs: Seq[FuConfig] => 329 fuTypeVec.map(fuType => 330 FuType.FuTypeOrR(fuType, fuCfgs.map(_.fuType))) 331 } 332 333 canIssueMergeAllBusy.zipWithIndex.foreach { case (merge, i) => 334 val mergeFuBusy = { 335 if (fuBusyTableWrite(i).nonEmpty) canIssueVec.asUInt & (~fuBusyTableMask(i)) 336 else canIssueVec.asUInt 337 } 338 val mergeIntWbBusy = { 339 if (intWbBusyTableRead(i).nonEmpty) mergeFuBusy & (~intWbBusyTableMask(i)) 340 else mergeFuBusy 341 } 342 val mergeVfWbBusy = { 343 if (vfWbBusyTableRead(i).nonEmpty) mergeIntWbBusy & (~vfWbBusyTableMask(i)) 344 else mergeIntWbBusy 345 } 346 merge := mergeVfWbBusy 347 } 348 349 deqCanIssue.zipWithIndex.foreach { case (req, i) => 350 req := canIssueMergeAllBusy(i) & VecInit(deqCanAcceptVec(i)).asUInt 351 } 352 dontTouch(fuTypeVec) 353 dontTouch(canIssueMergeAllBusy) 354 dontTouch(deqCanIssue) 355 356 if (params.numDeq == 2) { 357 require(params.deqFuSame || params.deqFuDiff, "The 2 deq ports need to be identical or completely different") 358 } 359 360 if (params.numDeq == 2 && params.deqFuSame) { 361 val subDeqPolicy = Module(new DeqPolicy()) 362 363 enqEntryOldestSel := DontCare 364 365 if (params.isAllComp || params.isAllSimp) { 366 othersEntryOldestSel(0) := AgeDetector(numEntries = params.numEntries - params.numEnq, 367 enq = othersEntryEnqSelVec.get, 368 canIssue = canIssueVec.asUInt(params.numEntries-1, params.numEnq) 369 ) 370 othersEntryOldestSel(1) := DontCare 371 372 subDeqPolicy.io.request := subDeqRequest.get 373 subDeqSelValidVec.get := subDeqPolicy.io.deqSelOHVec.map(oh => oh.valid) 374 subDeqSelOHVec.get := subDeqPolicy.io.deqSelOHVec.map(oh => oh.bits) 375 } 376 else { 377 simpAgeDetectRequest.get(0) := canIssueVec.asUInt(params.numEnq + params.numSimp - 1, params.numEnq) 378 simpAgeDetectRequest.get(1) := DontCare 379 simpAgeDetectRequest.get(params.numDeq) := VecInit(validVec.drop(params.numEnq).take(params.numSimp)).asUInt 380 if (params.numEnq == 2) { 381 simpAgeDetectRequest.get(params.numDeq + 1) := VecInit(validVec.drop(params.numEnq).take(params.numSimp)).asUInt & ~simpEntryOldestSel.get(params.numDeq).bits 382 } 383 384 simpEntryOldestSel.get := AgeDetector(numEntries = params.numSimp, 385 enq = simpEntryEnqSelVec.get, 386 canIssue = simpAgeDetectRequest.get 387 ) 388 389 compEntryOldestSel.get(0) := AgeDetector(numEntries = params.numComp, 390 enq = compEntryEnqSelVec.get, 391 canIssue = canIssueVec.asUInt(params.numEntries - 1, params.numEnq + params.numSimp) 392 ) 393 compEntryOldestSel.get(1) := DontCare 394 395 othersEntryOldestSel(0).valid := compEntryOldestSel.get(0).valid || simpEntryOldestSel.get(0).valid 396 othersEntryOldestSel(0).bits := Cat( 397 compEntryOldestSel.get(0).bits, 398 Fill(params.numSimp, !compEntryOldestSel.get(0).valid) & simpEntryOldestSel.get(0).bits, 399 ) 400 othersEntryOldestSel(1) := DontCare 401 402 subDeqPolicy.io.request := Reverse(subDeqRequest.get) 403 subDeqSelValidVec.get := subDeqPolicy.io.deqSelOHVec.map(oh => oh.valid) 404 subDeqSelOHVec.get := subDeqPolicy.io.deqSelOHVec.map(oh => Reverse(oh.bits)) 405 } 406 407 subDeqRequest.get := canIssueVec.asUInt & ~Cat(othersEntryOldestSel(0).bits, 0.U((params.numEnq).W)) 408 409 deqSelValidVec(0) := othersEntryOldestSel(0).valid || subDeqSelValidVec.get(1) 410 deqSelValidVec(1) := subDeqSelValidVec.get(0) 411 deqSelOHVec(0) := Mux(othersEntryOldestSel(0).valid, 412 Cat(othersEntryOldestSel(0).bits, 0.U((params.numEnq).W)), 413 subDeqSelOHVec.get(1)) & canIssueMergeAllBusy(0) 414 deqSelOHVec(1) := subDeqSelOHVec.get(0) & canIssueMergeAllBusy(1) 415 416 finalDeqSelValidVec.zip(finalDeqSelOHVec).zip(deqSelValidVec).zip(deqSelOHVec).zipWithIndex.foreach { case ((((selValid, selOH), deqValid), deqOH), i) => 417 selValid := deqValid && deqOH.orR && deqBeforeDly(i).ready 418 selOH := deqOH 419 } 420 } 421 else { 422 enqEntryOldestSel := NewAgeDetector(numEntries = params.numEnq, 423 enq = VecInit(s0_doEnqSelValidVec), 424 canIssue = VecInit(deqCanIssue.map(_(params.numEnq - 1, 0))) 425 ) 426 427 if (params.isAllComp || params.isAllSimp) { 428 othersEntryOldestSel := AgeDetector(numEntries = params.numEntries - params.numEnq, 429 enq = othersEntryEnqSelVec.get, 430 canIssue = VecInit(deqCanIssue.map(_(params.numEntries - 1, params.numEnq))) 431 ) 432 433 deqSelValidVec.zip(deqSelOHVec).zipWithIndex.foreach { case ((selValid, selOH), i) => 434 if (params.exuBlockParams(i).fuConfigs.contains(FuConfig.FakeHystaCfg)) { 435 selValid := false.B 436 selOH := 0.U.asTypeOf(selOH) 437 } else { 438 selValid := othersEntryOldestSel(i).valid || enqEntryOldestSel(i).valid 439 selOH := Cat(othersEntryOldestSel(i).bits, Fill(params.numEnq, !othersEntryOldestSel(i).valid) & enqEntryOldestSel(i).bits) 440 } 441 } 442 } 443 else { 444 othersEntryOldestSel := DontCare 445 446 deqCanIssue.zipWithIndex.foreach { case (req, i) => 447 simpAgeDetectRequest.get(i) := req(params.numEnq + params.numSimp - 1, params.numEnq) 448 } 449 simpAgeDetectRequest.get(params.numDeq) := VecInit(validVec.drop(params.numEnq).take(params.numSimp)).asUInt 450 if (params.numEnq == 2) { 451 simpAgeDetectRequest.get(params.numDeq + 1) := VecInit(validVec.drop(params.numEnq).take(params.numSimp)).asUInt & ~simpEntryOldestSel.get(params.numDeq).bits 452 } 453 454 simpEntryOldestSel.get := AgeDetector(numEntries = params.numSimp, 455 enq = simpEntryEnqSelVec.get, 456 canIssue = simpAgeDetectRequest.get 457 ) 458 459 compEntryOldestSel.get := AgeDetector(numEntries = params.numComp, 460 enq = compEntryEnqSelVec.get, 461 canIssue = VecInit(deqCanIssue.map(_(params.numEntries - 1, params.numEnq + params.numSimp))) 462 ) 463 464 deqSelValidVec.zip(deqSelOHVec).zipWithIndex.foreach { case ((selValid, selOH), i) => 465 if (params.exuBlockParams(i).fuConfigs.contains(FuConfig.FakeHystaCfg)) { 466 selValid := false.B 467 selOH := 0.U.asTypeOf(selOH) 468 } else { 469 selValid := compEntryOldestSel.get(i).valid || simpEntryOldestSel.get(i).valid || enqEntryOldestSel(i).valid 470 selOH := Cat( 471 compEntryOldestSel.get(i).bits, 472 Fill(params.numSimp, !compEntryOldestSel.get(i).valid) & simpEntryOldestSel.get(i).bits, 473 Fill(params.numEnq, !compEntryOldestSel.get(i).valid && !simpEntryOldestSel.get(i).valid) & enqEntryOldestSel(i).bits 474 ) 475 } 476 } 477 } 478 479 finalDeqSelValidVec.zip(finalDeqSelOHVec).zip(deqSelValidVec).zip(deqSelOHVec).zipWithIndex.foreach { case ((((selValid, selOH), deqValid), deqOH), i) => 480 selValid := deqValid && deqBeforeDly(i).ready 481 selOH := deqOH 482 } 483 } 484 485 val toBusyTableDeqResp = Wire(Vec(params.numDeq, ValidIO(new IssueQueueDeqRespBundle))) 486 487 toBusyTableDeqResp.zipWithIndex.foreach { case (deqResp, i) => 488 deqResp.valid := finalDeqSelValidVec(i) 489 deqResp.bits.resp := RespType.success 490 deqResp.bits.robIdx := DontCare 491 deqResp.bits.fuType := deqBeforeDly(i).bits.common.fuType 492 deqResp.bits.uopIdx.foreach(_ := DontCare) 493 } 494 495 //fuBusyTable 496 fuBusyTableWrite.zip(fuBusyTableRead).zipWithIndex.foreach { case ((busyTableWrite: Option[FuBusyTableWrite], busyTableRead: Option[FuBusyTableRead]), i) => 497 if(busyTableWrite.nonEmpty) { 498 val btwr = busyTableWrite.get 499 val btrd = busyTableRead.get 500 btwr.io.in.deqResp := toBusyTableDeqResp(i) 501 btwr.io.in.og0Resp := io.og0Resp(i) 502 btwr.io.in.og1Resp := io.og1Resp(i) 503 btrd.io.in.fuBusyTable := btwr.io.out.fuBusyTable 504 btrd.io.in.fuTypeRegVec := fuTypeVec 505 fuBusyTableMask(i) := btrd.io.out.fuBusyTableMask 506 } 507 else { 508 fuBusyTableMask(i) := 0.U(params.numEntries.W) 509 } 510 } 511 512 //wbfuBusyTable write 513 intWbBusyTableWrite.zip(intWbBusyTableOut).zip(intDeqRespSetOut).zipWithIndex.foreach { case (((busyTableWrite: Option[FuBusyTableWrite], busyTable: Option[UInt]), deqResp), i) => 514 if(busyTableWrite.nonEmpty) { 515 val btwr = busyTableWrite.get 516 val bt = busyTable.get 517 val dq = deqResp.get 518 btwr.io.in.deqResp := toBusyTableDeqResp(i) 519 btwr.io.in.og0Resp := io.og0Resp(i) 520 btwr.io.in.og1Resp := io.og1Resp(i) 521 bt := btwr.io.out.fuBusyTable 522 dq := btwr.io.out.deqRespSet 523 } 524 } 525 526 vfWbBusyTableWrite.zip(vfWbBusyTableOut).zip(vfDeqRespSetOut).zipWithIndex.foreach { case (((busyTableWrite: Option[FuBusyTableWrite], busyTable: Option[UInt]), deqResp), i) => 527 if (busyTableWrite.nonEmpty) { 528 val btwr = busyTableWrite.get 529 val bt = busyTable.get 530 val dq = deqResp.get 531 btwr.io.in.deqResp := toBusyTableDeqResp(i) 532 btwr.io.in.og0Resp := io.og0Resp(i) 533 btwr.io.in.og1Resp := io.og1Resp(i) 534 bt := btwr.io.out.fuBusyTable 535 dq := btwr.io.out.deqRespSet 536 } 537 } 538 539 //wbfuBusyTable read 540 intWbBusyTableRead.zip(intWbBusyTableIn).zipWithIndex.foreach { case ((busyTableRead: Option[FuBusyTableRead], busyTable: Option[UInt]), i) => 541 if(busyTableRead.nonEmpty) { 542 val btrd = busyTableRead.get 543 val bt = busyTable.get 544 btrd.io.in.fuBusyTable := bt 545 btrd.io.in.fuTypeRegVec := fuTypeVec 546 intWbBusyTableMask(i) := btrd.io.out.fuBusyTableMask 547 } 548 else { 549 intWbBusyTableMask(i) := 0.U(params.numEntries.W) 550 } 551 } 552 vfWbBusyTableRead.zip(vfWbBusyTableIn).zipWithIndex.foreach { case ((busyTableRead: Option[FuBusyTableRead], busyTable: Option[UInt]), i) => 553 if (busyTableRead.nonEmpty) { 554 val btrd = busyTableRead.get 555 val bt = busyTable.get 556 btrd.io.in.fuBusyTable := bt 557 btrd.io.in.fuTypeRegVec := fuTypeVec 558 vfWbBusyTableMask(i) := btrd.io.out.fuBusyTableMask 559 } 560 else { 561 vfWbBusyTableMask(i) := 0.U(params.numEntries.W) 562 } 563 } 564 565 wakeUpQueues.zipWithIndex.foreach { case (wakeUpQueueOption, i) => 566 wakeUpQueueOption.foreach { 567 wakeUpQueue => 568 val flush = Wire(new WakeupQueueFlush) 569 flush.redirect := io.flush 570 flush.ldCancel := io.ldCancel 571 flush.og0Fail := io.og0Resp(i).valid && RespType.isBlocked(io.og0Resp(i).bits.resp) 572 flush.og1Fail := io.og1Resp(i).valid && RespType.isBlocked(io.og1Resp(i).bits.resp) 573 wakeUpQueue.io.flush := flush 574 wakeUpQueue.io.enq.valid := deqBeforeDly(i).valid 575 wakeUpQueue.io.enq.bits.uop :<= deqBeforeDly(i).bits.common 576 wakeUpQueue.io.enq.bits.uop.pdestCopy.foreach(_ := 0.U) 577 wakeUpQueue.io.enq.bits.lat := getDeqLat(i, deqBeforeDly(i).bits.common.fuType) 578 } 579 } 580 581 deqBeforeDly.zipWithIndex.foreach { case (deq, i) => 582 deq.valid := finalDeqSelValidVec(i) && !cancelDeqVec(i) 583 deq.bits.addrOH := finalDeqSelOHVec(i) 584 deq.bits.common.isFirstIssue := deqFirstIssueVec(i) 585 deq.bits.common.iqIdx := OHToUInt(finalDeqSelOHVec(i)) 586 deq.bits.common.fuType := IQFuType.readFuType(deqEntryVec(i).bits.status.fuType, params.getFuCfgs.map(_.fuType)).asUInt 587 deq.bits.common.fuOpType := deqEntryVec(i).bits.payload.fuOpType 588 deq.bits.common.rfWen.foreach(_ := deqEntryVec(i).bits.payload.rfWen) 589 deq.bits.common.fpWen.foreach(_ := deqEntryVec(i).bits.payload.fpWen) 590 deq.bits.common.vecWen.foreach(_ := deqEntryVec(i).bits.payload.vecWen) 591 deq.bits.common.flushPipe.foreach(_ := deqEntryVec(i).bits.payload.flushPipe) 592 deq.bits.common.pdest := deqEntryVec(i).bits.payload.pdest 593 deq.bits.common.robIdx := deqEntryVec(i).bits.status.robIdx 594 595 require(deq.bits.common.dataSources.size <= finalDataSources(i).size) 596 deq.bits.common.dataSources.zip(finalDataSources(i)).foreach { case (sink, source) => sink := source} 597 deq.bits.common.l1ExuOH.foreach(_ := finalWakeUpL1ExuOH.get(i)) 598 deq.bits.common.srcTimer.foreach(_ := finalSrcTimer.get(i)) 599 deq.bits.common.loadDependency.foreach(_ := finalLoadDependency(i)) 600 deq.bits.common.src := DontCare 601 deq.bits.common.preDecode.foreach(_ := deqEntryVec(i).bits.payload.preDecodeInfo) 602 603 deq.bits.rf.zip(deqEntryVec(i).bits.status.srcStatus.map(_.psrc)).zip(deqEntryVec(i).bits.status.srcStatus.map(_.srcType)).foreach { case ((rf, psrc), srcType) => 604 // psrc in status array can be pregIdx of IntRegFile or VfRegFile 605 rf.foreach(_.addr := psrc) 606 rf.foreach(_.srcType := srcType) 607 } 608 deq.bits.srcType.zip(deqEntryVec(i).bits.status.srcStatus.map(_.srcType)).foreach { case (sink, source) => 609 sink := source 610 } 611 deq.bits.immType := deqEntryVec(i).bits.payload.selImm 612 deq.bits.common.imm := deqEntryVec(i).bits.imm.getOrElse(0.U) 613 614 deq.bits.common.perfDebugInfo := deqEntryVec(i).bits.payload.debugInfo 615 deq.bits.common.perfDebugInfo.selectTime := GTimer() 616 deq.bits.common.perfDebugInfo.issueTime := GTimer() + 1.U 617 } 618 619 private val deqShift = WireDefault(deqBeforeDly) 620 deqShift.zip(deqBeforeDly).foreach { 621 case (shifted, original) => 622 original.ready := shifted.ready // this will not cause combinational loop 623 shifted.bits.common.loadDependency.foreach( 624 _ := original.bits.common.loadDependency.get.map(_ << 1) 625 ) 626 } 627 io.deqDelay.zip(deqShift).foreach { case (deqDly, deq) => 628 NewPipelineConnect( 629 deq, deqDly, deqDly.valid, 630 false.B, 631 Option("Scheduler2DataPathPipe") 632 ) 633 } 634 if(backendParams.debugEn) { 635 dontTouch(io.deqDelay) 636 } 637 io.wakeupToIQ.zipWithIndex.foreach { case (wakeup, i) => 638 if (wakeUpQueues(i).nonEmpty && finalWakeUpL1ExuOH.nonEmpty) { 639 wakeup.valid := wakeUpQueues(i).get.io.deq.valid 640 wakeup.bits.fromExuInput(wakeUpQueues(i).get.io.deq.bits, finalWakeUpL1ExuOH.get(i)) 641 wakeup.bits.loadDependency := wakeUpQueues(i).get.io.deq.bits.loadDependency.getOrElse(0.U.asTypeOf(wakeup.bits.loadDependency)) 642 wakeup.bits.is0Lat := getDeqLat(i, wakeUpQueues(i).get.io.deq.bits.fuType) === 0.U 643 } else if (wakeUpQueues(i).nonEmpty) { 644 wakeup.valid := wakeUpQueues(i).get.io.deq.valid 645 wakeup.bits.fromExuInput(wakeUpQueues(i).get.io.deq.bits) 646 wakeup.bits.loadDependency := wakeUpQueues(i).get.io.deq.bits.loadDependency.getOrElse(0.U.asTypeOf(wakeup.bits.loadDependency)) 647 wakeup.bits.is0Lat := getDeqLat(i, wakeUpQueues(i).get.io.deq.bits.fuType) === 0.U 648 } else { 649 wakeup.valid := false.B 650 wakeup.bits := 0.U.asTypeOf(wakeup.bits) 651 wakeup.bits.is0Lat := 0.U 652 } 653 if (wakeUpQueues(i).nonEmpty) { 654 wakeup.bits.rfWen := (if (wakeUpQueues(i).get.io.deq.bits.rfWen .nonEmpty) wakeUpQueues(i).get.io.deq.valid && wakeUpQueues(i).get.io.deq.bits.rfWen .get else false.B) 655 wakeup.bits.fpWen := (if (wakeUpQueues(i).get.io.deq.bits.fpWen .nonEmpty) wakeUpQueues(i).get.io.deq.valid && wakeUpQueues(i).get.io.deq.bits.fpWen .get else false.B) 656 wakeup.bits.vecWen := (if (wakeUpQueues(i).get.io.deq.bits.vecWen.nonEmpty) wakeUpQueues(i).get.io.deq.valid && wakeUpQueues(i).get.io.deq.bits.vecWen.get else false.B) 657 } 658 659 if(wakeUpQueues(i).nonEmpty && wakeup.bits.pdestCopy.nonEmpty){ 660 wakeup.bits.pdestCopy.get := wakeUpQueues(i).get.io.deq.bits.pdestCopy.get 661 } 662 if (wakeUpQueues(i).nonEmpty && wakeup.bits.rfWenCopy.nonEmpty) { 663 wakeup.bits.rfWenCopy.get := wakeUpQueues(i).get.io.deq.bits.rfWenCopy.get 664 } 665 if (wakeUpQueues(i).nonEmpty && wakeup.bits.fpWenCopy.nonEmpty) { 666 wakeup.bits.fpWenCopy.get := wakeUpQueues(i).get.io.deq.bits.fpWenCopy.get 667 } 668 if (wakeUpQueues(i).nonEmpty && wakeup.bits.vecWenCopy.nonEmpty) { 669 wakeup.bits.vecWenCopy.get := wakeUpQueues(i).get.io.deq.bits.vecWenCopy.get 670 } 671 if (wakeUpQueues(i).nonEmpty && wakeup.bits.loadDependencyCopy.nonEmpty) { 672 wakeup.bits.loadDependencyCopy.get := wakeUpQueues(i).get.io.deq.bits.loadDependencyCopy.get 673 } 674 } 675 676 // Todo: better counter implementation 677 private val enqHasValid = validVec.take(params.numEnq).reduce(_ | _) 678 private val enqEntryValidCnt = PopCount(validVec.take(params.numEnq)) 679 private val othersValidCnt = PopCount(validVec.drop(params.numEnq)) 680 private val enqEntryValidCntDeq0 = PopCount( 681 validVec.take(params.numEnq).zip(deqCanAcceptVec(0).take(params.numEnq)).map { case (a, b) => a && b } 682 ) 683 private val othersValidCntDeq0 = PopCount( 684 validVec.drop(params.numEnq).zip(deqCanAcceptVec(0).drop(params.numEnq)).map { case (a, b) => a && b } 685 ) 686 private val enqEntryValidCntDeq1 = PopCount( 687 validVec.take(params.numEnq).zip(deqCanAcceptVec.last.take(params.numEnq)).map { case (a, b) => a && b } 688 ) 689 private val othersValidCntDeq1 = PopCount( 690 validVec.drop(params.numEnq).zip(deqCanAcceptVec.last.drop(params.numEnq)).map { case (a, b) => a && b } 691 ) 692 protected val deqCanAcceptVecEnq: Seq[IndexedSeq[Bool]] = deqFuCfgs.map { fuCfgs: Seq[FuConfig] => 693 io.enq.map(_.bits.fuType).map(fuType => 694 FuType.FuTypeOrR(fuType, fuCfgs.map(_.fuType))) 695 } 696 protected val enqValidCntDeq0 = PopCount(io.enq.map(_.fire).zip(deqCanAcceptVecEnq(0)).map { case (a, b) => a && b }) 697 protected val enqValidCntDeq1 = PopCount(io.enq.map(_.fire).zip(deqCanAcceptVecEnq.last).map { case (a, b) => a && b }) 698 io.validCntDeqVec.head := RegNext(enqEntryValidCntDeq0 +& othersValidCntDeq0 +& enqValidCntDeq0 - deqBeforeDly.head.fire) // validCntDeqVec(0) 699 io.validCntDeqVec.last := RegNext(enqEntryValidCntDeq1 +& othersValidCntDeq1 +& enqValidCntDeq1 - deqBeforeDly.last.fire) // validCntDeqVec(1) 700 io.status.leftVec(0) := validVec.drop(params.numEnq).reduce(_ & _) 701 for (i <- 0 until params.numEnq) { 702 io.status.leftVec(i + 1) := othersValidCnt === (params.numEntries - params.numEnq - (i + 1)).U 703 } 704 private val othersLeftOneCaseVec = Wire(Vec(params.numEntries - params.numEnq, UInt((params.numEntries - params.numEnq).W))) 705 othersLeftOneCaseVec.zipWithIndex.foreach { case (leftone, i) => 706 leftone := ~(1.U((params.numEntries - params.numEnq).W) << i) 707 } 708 private val othersLeftOne = othersLeftOneCaseVec.map(_ === VecInit(validVec.drop(params.numEnq)).asUInt).reduce(_ | _) 709 private val othersCanotIn = othersLeftOne || validVec.drop(params.numEnq).reduce(_ & _) 710 711 io.enq.foreach(_.ready := !othersCanotIn || !enqHasValid) 712 io.status.empty := !Cat(validVec).orR 713 io.status.full := othersCanotIn 714 io.status.validCnt := PopCount(validVec) 715 716 protected def getDeqLat(deqPortIdx: Int, fuType: UInt) : UInt = { 717 Mux1H(fuLatencyMaps(deqPortIdx) map { case (k, v) => (fuType(k.id), v.U) }) 718 } 719 720 // issue perf counter 721 // enq count 722 XSPerfAccumulate("enq_valid_cnt", PopCount(io.enq.map(_.fire))) 723 XSPerfAccumulate("enq_fire_cnt", PopCount(io.enq.map(_.fire))) 724 XSPerfAccumulate("enq_alu_fire_cnt", PopCount(io.enq.map { case enq => enq.fire && FuType.isAlu(enq.bits.fuType) })) 725 XSPerfAccumulate("enq_brh_fire_cnt", PopCount(io.enq.map { case enq => enq.fire && FuType.isBrh(enq.bits.fuType) })) 726 XSPerfAccumulate("deqDelay0_fire_cnt", PopCount(io.deqDelay.head.fire)) 727 XSPerfAccumulate("deqDelay1_fire_cnt", PopCount(io.deqDelay.last.fire)) 728 // valid count 729 XSPerfHistogram("enq_entry_valid_cnt", enqEntryValidCnt, true.B, 0, params.numEnq + 1) 730 XSPerfHistogram("other_entry_valid_cnt", othersValidCnt, true.B, 0, params.numEntries - params.numEnq + 1) 731 XSPerfHistogram("valid_cnt", PopCount(validVec), true.B, 0, params.numEntries + 1) 732 // only split when more than 1 func type 733 if (params.getFuCfgs.size > 0) { 734 for (t <- FuType.functionNameMap.keys) { 735 val fuName = FuType.functionNameMap(t) 736 if (params.getFuCfgs.map(_.fuType == t).reduce(_ | _)) { 737 XSPerfHistogram(s"valid_cnt_hist_futype_${fuName}", PopCount(validVec.zip(fuTypeVec).map { case (v, fu) => v && fu === t.U }), true.B, 0, params.numEntries, 1) 738 } 739 } 740 } 741 // ready instr count 742 private val readyEntriesCnt = PopCount(validVec.zip(canIssueVec).map(x => x._1 && x._2)) 743 XSPerfHistogram("ready_cnt", readyEntriesCnt, true.B, 0, params.numEntries + 1) 744 // only split when more than 1 func type 745 if (params.getFuCfgs.size > 0) { 746 for (t <- FuType.functionNameMap.keys) { 747 val fuName = FuType.functionNameMap(t) 748 if (params.getFuCfgs.map(_.fuType == t).reduce(_ | _)) { 749 XSPerfHistogram(s"ready_cnt_hist_futype_${fuName}", PopCount(validVec.zip(canIssueVec).zip(fuTypeVec).map { case ((v, c), fu) => v && c && fu === t.U }), true.B, 0, params.numEntries, 1) 750 } 751 } 752 } 753 754 // deq instr count 755 XSPerfAccumulate("issue_instr_pre_count", PopCount(deqBeforeDly.map(_.valid))) 756 XSPerfHistogram("issue_instr_pre_count_hist", PopCount(deqBeforeDly.map(_.valid)), true.B, 0, params.numDeq + 1, 1) 757 XSPerfAccumulate("issue_instr_count", PopCount(io.deqDelay.map(_.valid))) 758 XSPerfHistogram("issue_instr_count_hist", PopCount(io.deqDelay.map(_.valid)), true.B, 0, params.numDeq + 1, 1) 759 760 // deq instr data source count 761 XSPerfAccumulate("issue_datasource_reg", deqBeforeDly.map{ deq => 762 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.reg && !SrcType.isNotReg(deq.bits.srcType(j)) }) 763 }.reduce(_ +& _)) 764 XSPerfAccumulate("issue_datasource_bypass", deqBeforeDly.map{ deq => 765 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.bypass && !SrcType.isNotReg(deq.bits.srcType(j)) }) 766 }.reduce(_ +& _)) 767 XSPerfAccumulate("issue_datasource_forward", deqBeforeDly.map{ deq => 768 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.forward && !SrcType.isNotReg(deq.bits.srcType(j)) }) 769 }.reduce(_ +& _)) 770 XSPerfAccumulate("issue_datasource_noreg", deqBeforeDly.map{ deq => 771 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && SrcType.isNotReg(deq.bits.srcType(j)) }) 772 }.reduce(_ +& _)) 773 774 XSPerfHistogram("issue_datasource_reg_hist", deqBeforeDly.map{ deq => 775 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.reg && !SrcType.isNotReg(deq.bits.srcType(j)) }) 776 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 777 XSPerfHistogram("issue_datasource_bypass_hist", deqBeforeDly.map{ deq => 778 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.bypass && !SrcType.isNotReg(deq.bits.srcType(j)) }) 779 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 780 XSPerfHistogram("issue_datasource_forward_hist", deqBeforeDly.map{ deq => 781 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.forward && !SrcType.isNotReg(deq.bits.srcType(j)) }) 782 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 783 XSPerfHistogram("issue_datasource_noreg_hist", deqBeforeDly.map{ deq => 784 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && SrcType.isNotReg(deq.bits.srcType(j)) }) 785 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 786 787 // deq instr data source count for each futype 788 for (t <- FuType.functionNameMap.keys) { 789 val fuName = FuType.functionNameMap(t) 790 if (params.getFuCfgs.map(_.fuType == t).reduce(_ | _)) { 791 XSPerfAccumulate(s"issue_datasource_reg_futype_${fuName}", deqBeforeDly.map{ deq => 792 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.reg && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 793 }.reduce(_ +& _)) 794 XSPerfAccumulate(s"issue_datasource_bypass_futype_${fuName}", deqBeforeDly.map{ deq => 795 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.bypass && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 796 }.reduce(_ +& _)) 797 XSPerfAccumulate(s"issue_datasource_forward_futype_${fuName}", deqBeforeDly.map{ deq => 798 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.forward && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 799 }.reduce(_ +& _)) 800 XSPerfAccumulate(s"issue_datasource_noreg_futype_${fuName}", deqBeforeDly.map{ deq => 801 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 802 }.reduce(_ +& _)) 803 804 XSPerfHistogram(s"issue_datasource_reg_hist_futype_${fuName}", deqBeforeDly.map{ deq => 805 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.reg && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 806 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 807 XSPerfHistogram(s"issue_datasource_bypass_hist_futype_${fuName}", deqBeforeDly.map{ deq => 808 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.bypass && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 809 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 810 XSPerfHistogram(s"issue_datasource_forward_hist_futype_${fuName}", deqBeforeDly.map{ deq => 811 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && ds.value === DataSource.forward && !SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 812 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 813 XSPerfHistogram(s"issue_datasource_noreg_hist_futype_${fuName}", deqBeforeDly.map{ deq => 814 PopCount(deq.bits.common.dataSources.zipWithIndex.map{ case (ds, j) => deq.valid && SrcType.isNotReg(deq.bits.srcType(j)) && deq.bits.common.fuType === t.U }) 815 }.reduce(_ +& _), true.B, 0, params.numDeq * params.numRegSrc + 1, 1) 816 } 817 } 818 819 // cancel instr count 820 if (params.hasIQWakeUp) { 821 val cancelVec: Vec[Bool] = entries.io.cancel.get 822 XSPerfAccumulate("cancel_instr_count", PopCount(validVec.zip(cancelVec).map(x => x._1 & x._2))) 823 XSPerfHistogram("cancel_instr_hist", PopCount(validVec.zip(cancelVec).map(x => x._1 & x._2)), true.B, 0, params.numEntries, 1) 824 for (t <- FuType.functionNameMap.keys) { 825 val fuName = FuType.functionNameMap(t) 826 if (params.getFuCfgs.map(_.fuType == t).reduce(_ | _)) { 827 XSPerfAccumulate(s"cancel_instr_count_futype_${fuName}", PopCount(validVec.zip(cancelVec).zip(fuTypeVec).map{ case ((x, y), fu) => x & y & fu === t.U })) 828 XSPerfHistogram(s"cancel_instr_hist_futype_${fuName}", PopCount(validVec.zip(cancelVec).zip(fuTypeVec).map{ case ((x, y), fu) => x & y & fu === t.U }), true.B, 0, params.numEntries, 1) 829 } 830 } 831 } 832} 833 834class IssueQueueJumpBundle extends Bundle { 835 val pc = UInt(VAddrData().dataWidth.W) 836} 837 838class IssueQueueLoadBundle(implicit p: Parameters) extends XSBundle { 839 val fastMatch = UInt(backendParams.LduCnt.W) 840 val fastImm = UInt(12.W) 841} 842 843class IssueQueueIntIO()(implicit p: Parameters, params: IssueBlockParams) extends IssueQueueIO 844 845class IssueQueueIntImp(override val wrapper: IssueQueue)(implicit p: Parameters, iqParams: IssueBlockParams) 846 extends IssueQueueImp(wrapper) 847{ 848 io.suggestName("none") 849 override lazy val io = IO(new IssueQueueIntIO).suggestName("io") 850 851 deqBeforeDly.zipWithIndex.foreach{ case (deq, i) => { 852 deq.bits.common.pc.foreach(_ := deqEntryVec(i).bits.payload.pc) 853 deq.bits.common.preDecode.foreach(_ := deqEntryVec(i).bits.payload.preDecodeInfo) 854 deq.bits.common.ftqIdx.foreach(_ := deqEntryVec(i).bits.payload.ftqPtr) 855 deq.bits.common.ftqOffset.foreach(_ := deqEntryVec(i).bits.payload.ftqOffset) 856 deq.bits.common.predictInfo.foreach(x => { 857 x.target := DontCare 858 x.taken := deqEntryVec(i).bits.payload.pred_taken 859 }) 860 // for std 861 deq.bits.common.sqIdx.foreach(_ := deqEntryVec(i).bits.payload.sqIdx) 862 // for i2f 863 deq.bits.common.fpu.foreach(_ := deqEntryVec(i).bits.payload.fpu) 864 }} 865} 866 867class IssueQueueVfImp(override val wrapper: IssueQueue)(implicit p: Parameters, iqParams: IssueBlockParams) 868 extends IssueQueueImp(wrapper) 869{ 870 s0_enqBits.foreach{ x => 871 x.srcType(3) := SrcType.vp // v0: mask src 872 x.srcType(4) := SrcType.vp // vl&vtype 873 } 874 deqBeforeDly.zipWithIndex.foreach{ case (deq, i) => { 875 deq.bits.common.fpu.foreach(_ := deqEntryVec(i).bits.payload.fpu) 876 deq.bits.common.vpu.foreach(_ := deqEntryVec(i).bits.payload.vpu) 877 deq.bits.common.vpu.foreach(_.vuopIdx := deqEntryVec(i).bits.payload.uopIdx) 878 deq.bits.common.vpu.foreach(_.lastUop := deqEntryVec(i).bits.payload.lastUop) 879 }} 880} 881 882class IssueQueueMemBundle(implicit p: Parameters, params: IssueBlockParams) extends Bundle { 883 val feedbackIO = Flipped(Vec(params.numDeq, new MemRSFeedbackIO)) 884 val checkWait = new Bundle { 885 val stIssuePtr = Input(new SqPtr) 886 val memWaitUpdateReq = Flipped(new MemWaitUpdateReq) 887 } 888 val loadFastMatch = Output(Vec(params.LdExuCnt, new IssueQueueLoadBundle)) 889 val loadWakeUp = Input(Vec(params.LdExuCnt, ValidIO(new DynInst()))) 890 891 // vector 892 val sqDeqPtr = OptionWrapper(params.isVecMemIQ, Input(new SqPtr)) 893 val lqDeqPtr = OptionWrapper(params.isVecMemIQ, Input(new LqPtr)) 894} 895 896class IssueQueueMemIO(implicit p: Parameters, params: IssueBlockParams) extends IssueQueueIO { 897 val memIO = Some(new IssueQueueMemBundle) 898} 899 900class IssueQueueMemAddrImp(override val wrapper: IssueQueue)(implicit p: Parameters, params: IssueBlockParams) 901 extends IssueQueueImp(wrapper) with HasCircularQueuePtrHelper { 902 903 require(params.StdCnt == 0 && (params.LduCnt + params.StaCnt + params.HyuCnt) > 0, "IssueQueueMemAddrImp can only be instance of MemAddr IQ, " + 904 s"StdCnt: ${params.StdCnt}, LduCnt: ${params.LduCnt}, StaCnt: ${params.StaCnt}, HyuCnt: ${params.HyuCnt}") 905 println(s"[IssueQueueMemAddrImp] StdCnt: ${params.StdCnt}, LduCnt: ${params.LduCnt}, StaCnt: ${params.StaCnt}, HyuCnt: ${params.HyuCnt}") 906 907 io.suggestName("none") 908 override lazy val io = IO(new IssueQueueMemIO).suggestName("io") 909 private val memIO = io.memIO.get 910 911 memIO.loadFastMatch := 0.U.asTypeOf(memIO.loadFastMatch) // TODO: is still needed? 912 913 for (i <- io.enq.indices) { 914 val blockNotReleased = isAfter(io.enq(i).bits.sqIdx, memIO.checkWait.stIssuePtr) 915 val storeAddrWaitForIsIssuing = VecInit((0 until StorePipelineWidth).map(i => { 916 memIO.checkWait.memWaitUpdateReq.robIdx(i).valid && 917 memIO.checkWait.memWaitUpdateReq.robIdx(i).bits.value === io.enq(i).bits.waitForRobIdx.value 918 })).asUInt.orR && !io.enq(i).bits.loadWaitStrict // is waiting for store addr ready 919 s0_enqBits(i).loadWaitBit := io.enq(i).bits.loadWaitBit && !storeAddrWaitForIsIssuing && blockNotReleased 920 } 921 922 for (i <- entries.io.enq.indices) { 923 entries.io.enq(i).bits.status match { case enqData => 924 enqData.blocked := false.B // s0_enqBits(i).loadWaitBit 925 enqData.mem.get.strictWait := s0_enqBits(i).loadWaitStrict 926 enqData.mem.get.waitForStd := false.B 927 enqData.mem.get.waitForRobIdx := s0_enqBits(i).waitForRobIdx 928 enqData.mem.get.waitForSqIdx := 0.U.asTypeOf(enqData.mem.get.waitForSqIdx) // generated by sq, will be updated later 929 enqData.mem.get.sqIdx := s0_enqBits(i).sqIdx 930 } 931 } 932 entries.io.fromMem.get.slowResp.zipWithIndex.foreach { case (slowResp, i) => 933 slowResp.valid := memIO.feedbackIO(i).feedbackSlow.valid 934 slowResp.bits.robIdx := memIO.feedbackIO(i).feedbackSlow.bits.robIdx 935 slowResp.bits.resp := Mux(memIO.feedbackIO(i).feedbackSlow.bits.hit, RespType.success, RespType.block) 936 slowResp.bits.fuType := DontCare 937 } 938 939 entries.io.fromMem.get.fastResp.zipWithIndex.foreach { case (fastResp, i) => 940 fastResp.valid := memIO.feedbackIO(i).feedbackFast.valid 941 fastResp.bits.robIdx := memIO.feedbackIO(i).feedbackFast.bits.robIdx 942 fastResp.bits.resp := Mux(memIO.feedbackIO(i).feedbackFast.bits.hit, RespType.success, RespType.block) 943 fastResp.bits.fuType := DontCare 944 } 945 946 947 entries.io.fromMem.get.memWaitUpdateReq := memIO.checkWait.memWaitUpdateReq 948 entries.io.fromMem.get.stIssuePtr := memIO.checkWait.stIssuePtr 949 950 // load wakeup 951 val loadWakeUpIter = memIO.loadWakeUp.iterator 952 io.wakeupToIQ.zip(params.exuBlockParams).zipWithIndex.foreach { case ((wakeup, param), i) => 953 if (param.hasLoadExu) { 954 require(wakeUpQueues(i).isEmpty) 955 val uop = loadWakeUpIter.next() 956 957 wakeup.valid := RegNext(uop.fire) 958 wakeup.bits.rfWen := RegNext(uop.bits.rfWen && uop.fire) 959 wakeup.bits.fpWen := RegNext(uop.bits.fpWen && uop.fire) 960 wakeup.bits.vecWen := RegNext(uop.bits.vecWen && uop.fire) 961 wakeup.bits.pdest := RegNext(uop.bits.pdest) 962 wakeup.bits.loadDependency.foreach(_ := 0.U) // this is correct for load only 963 964 wakeup.bits.rfWenCopy .foreach(_.foreach(_ := RegNext(uop.bits.rfWen && uop.fire))) 965 wakeup.bits.fpWenCopy .foreach(_.foreach(_ := RegNext(uop.bits.fpWen && uop.fire))) 966 wakeup.bits.vecWenCopy.foreach(_.foreach(_ := RegNext(uop.bits.vecWen && uop.fire))) 967 wakeup.bits.pdestCopy .foreach(_.foreach(_ := RegNext(uop.bits.pdest))) 968 wakeup.bits.loadDependencyCopy.foreach(x => x := 0.U.asTypeOf(x)) // this is correct for load only 969 970 wakeup.bits.is0Lat := 0.U 971 } 972 } 973 require(!loadWakeUpIter.hasNext) 974 975 deqBeforeDly.zipWithIndex.foreach { case (deq, i) => 976 deq.bits.common.loadWaitBit.foreach(_ := deqEntryVec(i).bits.payload.loadWaitBit) 977 deq.bits.common.waitForRobIdx.foreach(_ := deqEntryVec(i).bits.payload.waitForRobIdx) 978 deq.bits.common.storeSetHit.foreach(_ := deqEntryVec(i).bits.payload.storeSetHit) 979 deq.bits.common.loadWaitStrict.foreach(_ := deqEntryVec(i).bits.payload.loadWaitStrict) 980 deq.bits.common.ssid.foreach(_ := deqEntryVec(i).bits.payload.ssid) 981 deq.bits.common.sqIdx.get := deqEntryVec(i).bits.payload.sqIdx 982 deq.bits.common.lqIdx.get := deqEntryVec(i).bits.payload.lqIdx 983 deq.bits.common.ftqIdx.foreach(_ := deqEntryVec(i).bits.payload.ftqPtr) 984 deq.bits.common.ftqOffset.foreach(_ := deqEntryVec(i).bits.payload.ftqOffset) 985 } 986} 987 988class IssueQueueVecMemImp(override val wrapper: IssueQueue)(implicit p: Parameters, params: IssueBlockParams) 989 extends IssueQueueImp(wrapper) with HasCircularQueuePtrHelper { 990 991 require((params.VstdCnt + params.VlduCnt + params.VstaCnt) > 0, "IssueQueueVecMemImp can only be instance of VecMem IQ") 992 993 io.suggestName("none") 994 override lazy val io = IO(new IssueQueueMemIO).suggestName("io") 995 private val memIO = io.memIO.get 996 997 def selectOldUop(robIdx: Seq[RobPtr], uopIdx: Seq[UInt], valid: Seq[Bool]): Vec[Bool] = { 998 val compareVec = (0 until robIdx.length).map(i => (0 until i).map(j => isAfter(robIdx(j), robIdx(i)) || (robIdx(j).value === robIdx(i).value && uopIdx(i) < uopIdx(j)))) 999 val resultOnehot = VecInit((0 until robIdx.length).map(i => Cat((0 until robIdx.length).map(j => 1000 (if (j < i) !valid(j) || compareVec(i)(j) 1001 else if (j == i) valid(i) 1002 else !valid(j) || !compareVec(j)(i)) 1003 )).andR)) 1004 resultOnehot 1005 } 1006 1007 val robIdxVec = entries.io.robIdx.get 1008 val uopIdxVec = entries.io.uopIdx.get 1009 val allEntryOldestOH = selectOldUop(robIdxVec, uopIdxVec, validVec) 1010 1011 finalDeqSelValidVec.head := (allEntryOldestOH.asUInt & canIssueVec.asUInt).orR 1012 finalDeqSelOHVec.head := allEntryOldestOH.asUInt & canIssueVec.asUInt 1013 1014 if (params.isVecMemAddrIQ) { 1015 s0_enqBits.foreach{ x => 1016 x.srcType(3) := SrcType.vp // v0: mask src 1017 x.srcType(4) := SrcType.vp // vl&vtype 1018 } 1019 1020 for (i <- io.enq.indices) { 1021 s0_enqBits(i).loadWaitBit := false.B 1022 } 1023 1024 for (i <- entries.io.enq.indices) { 1025 entries.io.enq(i).bits.status match { case enqData => 1026 enqData.blocked := false.B // s0_enqBits(i).loadWaitBit 1027 enqData.mem.get.strictWait := s0_enqBits(i).loadWaitStrict 1028 enqData.mem.get.waitForStd := false.B 1029 enqData.mem.get.waitForRobIdx := s0_enqBits(i).waitForRobIdx 1030 enqData.mem.get.waitForSqIdx := 0.U.asTypeOf(enqData.mem.get.waitForSqIdx) // generated by sq, will be updated later 1031 enqData.mem.get.sqIdx := s0_enqBits(i).sqIdx 1032 } 1033 1034 entries.io.fromMem.get.slowResp.zipWithIndex.foreach { case (slowResp, i) => 1035 slowResp.valid := memIO.feedbackIO(i).feedbackSlow.valid 1036 slowResp.bits.robIdx := memIO.feedbackIO(i).feedbackSlow.bits.robIdx 1037 slowResp.bits.resp := Mux(memIO.feedbackIO(i).feedbackSlow.bits.hit, RespType.success, RespType.block) 1038 slowResp.bits.fuType := DontCare 1039 } 1040 1041 entries.io.fromMem.get.fastResp.zipWithIndex.foreach { case (fastResp, i) => 1042 fastResp.valid := memIO.feedbackIO(i).feedbackFast.valid 1043 fastResp.bits.robIdx := memIO.feedbackIO(i).feedbackFast.bits.robIdx 1044 fastResp.bits.resp := Mux(memIO.feedbackIO(i).feedbackFast.bits.hit, RespType.success, RespType.block) 1045 fastResp.bits.fuType := DontCare 1046 fastResp.bits.uopIdx.get := 0.U //todo 1047 } 1048 1049 entries.io.fromMem.get.memWaitUpdateReq := memIO.checkWait.memWaitUpdateReq 1050 entries.io.fromMem.get.stIssuePtr := memIO.checkWait.stIssuePtr 1051 } 1052 } 1053 1054 for (i <- entries.io.enq.indices) { 1055 entries.io.enq(i).bits.status.vecMem.get match { 1056 case enqData => 1057 enqData.sqIdx := s0_enqBits(i).sqIdx 1058 enqData.lqIdx := s0_enqBits(i).lqIdx 1059 enqData.uopIdx := s0_enqBits(i).uopIdx 1060 } 1061 } 1062 1063 entries.io.vecMemIn.get.sqDeqPtr := memIO.sqDeqPtr.get 1064 entries.io.vecMemIn.get.lqDeqPtr := memIO.lqDeqPtr.get 1065 1066 1067 entries.io.fromMem.get.slowResp.zipWithIndex.foreach { case (resp, i) => 1068 resp.bits.uopIdx.get := 0.U // Todo 1069 } 1070 1071 deqBeforeDly.zipWithIndex.foreach { case (deq, i) => 1072 deq.bits.common.sqIdx.foreach(_ := deqEntryVec(i).bits.payload.sqIdx) 1073 deq.bits.common.lqIdx.foreach(_ := deqEntryVec(i).bits.payload.lqIdx) 1074 if (params.isVecLdAddrIQ) { 1075 deq.bits.common.ftqIdx.get := deqEntryVec(i).bits.payload.ftqPtr 1076 deq.bits.common.ftqOffset.get := deqEntryVec(i).bits.payload.ftqOffset 1077 } 1078 deq.bits.common.fpu.foreach(_ := deqEntryVec(i).bits.payload.fpu) 1079 deq.bits.common.vpu.foreach(_ := deqEntryVec(i).bits.payload.vpu) 1080 deq.bits.common.vpu.foreach(_.vuopIdx := deqEntryVec(i).bits.payload.uopIdx) 1081 deq.bits.common.vpu.foreach(_.lastUop := deqEntryVec(i).bits.payload.lastUop) 1082 } 1083} 1084