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