1package xiangshan.backend.issue 2 3import org.chipsalliance.cde.config.Parameters 4import chisel3._ 5import chisel3.util._ 6import ujson.IndexedValue.True 7import utils.MathUtils 8import utility.{HasCircularQueuePtrHelper, XSError} 9import xiangshan._ 10import xiangshan.backend.Bundles._ 11import xiangshan.backend.datapath.DataSource 12import xiangshan.backend.fu.FuType 13import xiangshan.backend.fu.vector.Bundles.NumLsElem 14import xiangshan.backend.rob.RobPtr 15import xiangshan.mem.{LqPtr, MemWaitUpdateReq, SqPtr} 16 17object EntryBundles extends HasCircularQueuePtrHelper { 18 19 class Status(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 20 //basic status 21 val robIdx = new RobPtr 22 val fuType = IQFuType() 23 //src status 24 val srcStatus = Vec(params.numRegSrc, new SrcStatus) 25 //issue status 26 val blocked = Bool() 27 val issued = Bool() 28 val firstIssue = Bool() 29 val issueTimer = UInt(2.W) 30 val deqPortIdx = UInt(1.W) 31 //vector mem status 32 val vecMem = Option.when(params.isVecMemIQ)(new StatusVecMemPart) 33 34 def srcReady: Bool = { 35 VecInit(srcStatus.map(_.srcState).map(SrcState.isReady)).asUInt.andR 36 } 37 38 def canIssue: Bool = { 39 srcReady && !issued && !blocked 40 } 41 42 def mergedLoadDependency: Vec[UInt] = { 43 srcStatus.map(_.srcLoadDependency).reduce({ 44 case (l: Vec[UInt], r: Vec[UInt]) => VecInit(l.zip(r).map(x => x._1 | x._2)) 45 }: (Vec[UInt], Vec[UInt]) => Vec[UInt]) 46 } 47 } 48 49 class SrcStatus(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 50 val psrc = UInt(params.rdPregIdxWidth.W) 51 val srcType = SrcType() 52 val srcState = SrcState() 53 val dataSources = DataSource() 54 val srcLoadDependency = Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W)) 55 val srcWakeUpL1ExuOH = Option.when(params.hasIQWakeUp)(ExuVec()) 56 //reg cache 57 val useRegCache = Option.when(params.needReadRegCache)(Bool()) 58 val regCacheIdx = Option.when(params.needReadRegCache)(UInt(RegCacheIdxWidth.W)) 59 } 60 61 class StatusVecMemPart(implicit p:Parameters, params: IssueBlockParams) extends Bundle { 62 val sqIdx = new SqPtr 63 val lqIdx = new LqPtr 64 val numLsElem = NumLsElem() 65 } 66 67 class EntryDeqRespBundle(implicit p: Parameters, val params: IssueBlockParams) extends XSBundle { 68 val robIdx = new RobPtr 69 val resp = RespType() 70 val fuType = FuType() 71 val uopIdx = Option.when(params.isVecMemIQ)(Output(UopIdx())) 72 val sqIdx = Option.when(params.needFeedBackSqIdx)(new SqPtr()) 73 val lqIdx = Option.when(params.needFeedBackLqIdx)(new LqPtr()) 74 } 75 76 object RespType { 77 def apply() = UInt(2.W) 78 79 def isBlocked(resp: UInt) = { 80 resp === block 81 } 82 83 def succeed(resp: UInt) = { 84 resp === success 85 } 86 87 val block = "b00".U 88 val uncertain = "b01".U 89 val success = "b11".U 90 } 91 92 class EntryBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 93 val status = new Status() 94 val imm = Option.when(params.needImm)(UInt((params.deqImmTypesMaxLen).W)) 95 val payload = new DynInst() 96 } 97 98 class CommonInBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 99 val flush = Flipped(ValidIO(new Redirect)) 100 val enq = Flipped(ValidIO(new EntryBundle)) 101 //wakeup 102 val wakeUpFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle) 103 val wakeUpFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle) 104 // vl 105 val vlFromIntIsZero = Input(Bool()) 106 val vlFromIntIsVlmax = Input(Bool()) 107 val vlFromVfIsZero = Input(Bool()) 108 val vlFromVfIsVlmax = Input(Bool()) 109 //cancel 110 val og0Cancel = Input(ExuVec()) 111 val og1Cancel = Input(ExuVec()) 112 val ldCancel = Vec(backendParams.LdExuCnt, Flipped(new LoadCancelIO)) 113 //deq sel 114 val deqSel = Input(Bool()) 115 val deqPortIdxWrite = Input(UInt(1.W)) 116 val issueResp = Flipped(ValidIO(new EntryDeqRespBundle)) 117 //trans sel 118 val transSel = Input(Bool()) 119 // vector mem only 120 val fromLsq = Option.when(params.isVecMemIQ)(new Bundle { 121 val sqDeqPtr = Input(new SqPtr) 122 val lqDeqPtr = Input(new LqPtr) 123 }) 124 } 125 126 class CommonOutBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 127 //status 128 val valid = Output(Bool()) 129 val issued = Output(Bool()) 130 val canIssue = Output(Bool()) 131 val fuType = Output(FuType()) 132 val robIdx = Output(new RobPtr) 133 val uopIdx = Option.when(params.isVecMemIQ)(Output(UopIdx())) 134 //src 135 val dataSource = Vec(params.numRegSrc, Output(DataSource())) 136 val srcWakeUpL1ExuOH = Option.when(params.hasIQWakeUp)(Vec(params.numRegSrc, Output(ExuVec()))) 137 //deq 138 val isFirstIssue = Output(Bool()) 139 val entry = ValidIO(new EntryBundle) 140 val cancelBypass = Output(Bool()) 141 val deqPortIdxRead = Output(UInt(1.W)) 142 val issueTimerRead = Output(UInt(2.W)) 143 //trans 144 val enqReady = Output(Bool()) 145 val transEntry = ValidIO(new EntryBundle) 146 // debug 147 val entryInValid = Output(Bool()) 148 val entryOutDeqValid = Output(Bool()) 149 val entryOutTransValid = Output(Bool()) 150 val perfLdCancel = Option.when(params.hasIQWakeUp)(Output(Vec(params.numRegSrc, Bool()))) 151 val perfOg0Cancel = Option.when(params.hasIQWakeUp)(Output(Vec(params.numRegSrc, Bool()))) 152 val perfWakeupByWB = Output(Vec(params.numRegSrc, Bool())) 153 val perfWakeupByIQ = Option.when(params.hasIQWakeUp)(Output(Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())))) 154 } 155 156 class CommonWireBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 157 val validRegNext = Bool() 158 val flushed = Bool() 159 val clear = Bool() 160 val canIssue = Bool() 161 val enqReady = Bool() 162 val deqSuccess = Bool() 163 val srcWakeupByWB = Vec(params.numRegSrc, Bool()) 164 val vlWakeupByIntWb = Bool() 165 val vlWakeupByVfWb = Bool() 166 val srcCancelVec = Vec(params.numRegSrc, Bool()) 167 val srcLoadCancelVec = Vec(params.numRegSrc, Bool()) 168 val srcLoadTransCancelVec = Vec(params.numRegSrc, Bool()) 169 val srcLoadDependencyNext = Vec(params.numRegSrc, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W))) 170 } 171 172 def CommonWireConnect(common: CommonWireBundle, hasIQWakeup: Option[CommonIQWakeupBundle], validReg: Bool, status: Status, commonIn: CommonInBundle, isEnq: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 173 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 174 common.flushed := status.robIdx.needFlush(commonIn.flush) 175 common.deqSuccess := (if (params.isVecMemIQ) status.issued else true.B) && 176 commonIn.issueResp.valid && RespType.succeed(commonIn.issueResp.bits.resp) && !common.srcLoadCancelVec.asUInt.orR 177 common.srcWakeupByWB := commonIn.wakeUpFromWB.map{ bundle => 178 val psrcSrcTypeVec = status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType) 179 if (params.numRegSrc == 5) { 180 bundle.bits.wakeUp(psrcSrcTypeVec.take(3), bundle.valid) :+ 181 bundle.bits.wakeUpV0(psrcSrcTypeVec(3), bundle.valid) :+ 182 bundle.bits.wakeUpVl(psrcSrcTypeVec(4), bundle.valid) 183 } 184 else 185 bundle.bits.wakeUp(psrcSrcTypeVec, bundle.valid) 186 }.transpose.map(x => VecInit(x.toSeq).asUInt.orR).toSeq 187 common.canIssue := validReg && status.canIssue 188 common.enqReady := !validReg || commonIn.transSel 189 common.clear := common.flushed || common.deqSuccess || commonIn.transSel 190 common.srcCancelVec.zip(hasIQWakeupGet.srcWakeupByIQWithoutCancel).zipWithIndex.foreach { case ((srcCancel, wakeUpByIQVec), srcIdx) => 191 common.srcLoadTransCancelVec(srcIdx) := (if(params.hasIQWakeUp) Mux1H(wakeUpByIQVec, hasIQWakeupGet.wakeupLoadDependencyByIQVec.map(dep => LoadShouldCancel(Some(dep), commonIn.ldCancel))) else false.B) 192 common.srcLoadCancelVec(srcIdx) := LoadShouldCancel(Some(status.srcStatus(srcIdx).srcLoadDependency), commonIn.ldCancel) 193 srcCancel := common.srcLoadTransCancelVec(srcIdx) || common.srcLoadCancelVec(srcIdx) 194 } 195 common.srcLoadDependencyNext.zip(status.srcStatus.map(_.srcLoadDependency)).foreach { case (ldsNext, lds) => 196 ldsNext.zip(lds).foreach{ case (ldNext, ld) => ldNext := ld << 1 } 197 } 198 if(isEnq) { 199 common.validRegNext := Mux(commonIn.enq.valid && common.enqReady, true.B, Mux(common.clear, false.B, validReg)) 200 } else { 201 common.validRegNext := Mux(commonIn.enq.valid, true.B, Mux(common.clear, false.B, validReg)) 202 } 203 if (params.numRegSrc == 5) { 204 // only when numRegSrc == 5 need vl 205 val wakeUpFromVl = VecInit(commonIn.wakeUpFromWB.map{ bundle => 206 val psrcSrcTypeVec = status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType) 207 bundle.bits.wakeUpVl(psrcSrcTypeVec(4), bundle.valid) 208 }) 209 var numVecWb = params.backendParam.getVfWBExeGroup.size 210 var numV0Wb = params.backendParam.getV0WBExeGroup.size 211 // int wb is first bit of vlwb, which is after vfwb and v0wb 212 common.vlWakeupByIntWb := wakeUpFromVl(numVecWb + numV0Wb) 213 // vf wb is second bit of wb 214 common.vlWakeupByVfWb := wakeUpFromVl(numVecWb + numV0Wb + 1) 215 } else { 216 common.vlWakeupByIntWb := false.B 217 common.vlWakeupByVfWb := false.B 218 } 219 } 220 221 class CommonIQWakeupBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 222 val srcWakeupByIQ = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 223 val srcWakeupByIQWithoutCancel = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 224 val srcWakeupByIQButCancel = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 225 val srcWakeupL1ExuOH = Vec(params.numRegSrc, ExuVec()) 226 val wakeupLoadDependencyByIQVec = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W))) 227 val shiftedWakeupLoadDependencyByIQVec = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W))) 228 val canIssueBypass = Bool() 229 } 230 231 def CommonIQWakeupConnect(common: CommonWireBundle, hasIQWakeupGet: CommonIQWakeupBundle, validReg: Bool, status: Status, commonIn: CommonInBundle, isEnq: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 232 val wakeupVec: Seq[Seq[Bool]] = commonIn.wakeUpFromIQ.map{(bundle: ValidIO[IssueQueueIQWakeUpBundle]) => 233 val psrcSrcTypeVec = status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType) 234 if (params.numRegSrc == 5) { 235 bundle.bits.wakeUpFromIQ(psrcSrcTypeVec.take(3)) :+ 236 bundle.bits.wakeUpV0FromIQ(psrcSrcTypeVec(3)) :+ 237 bundle.bits.wakeUpVlFromIQ(psrcSrcTypeVec(4)) 238 } 239 else 240 bundle.bits.wakeUpFromIQ(psrcSrcTypeVec) 241 }.toSeq.transpose 242 val cancelSel = params.wakeUpSourceExuIdx.zip(commonIn.wakeUpFromIQ).map { case (x, y) => commonIn.og0Cancel(x) && y.bits.is0Lat } 243 244 hasIQWakeupGet.srcWakeupByIQ := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && !cancel })) 245 hasIQWakeupGet.srcWakeupByIQButCancel := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && cancel })) 246 hasIQWakeupGet.srcWakeupByIQWithoutCancel := wakeupVec.map(x => VecInit(x)) 247 hasIQWakeupGet.wakeupLoadDependencyByIQVec := commonIn.wakeUpFromIQ.map(_.bits.loadDependency).toSeq 248 hasIQWakeupGet.srcWakeupL1ExuOH.zip(status.srcStatus.map(_.srcWakeUpL1ExuOH.get)).foreach { 249 case (exuOH, regExuOH) => 250 exuOH := 0.U.asTypeOf(exuOH) 251 params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := regExuOH(x)) 252 } 253 hasIQWakeupGet.canIssueBypass := validReg && !status.issued && !status.blocked && 254 VecInit(status.srcStatus.map(_.srcState).zip(hasIQWakeupGet.srcWakeupByIQWithoutCancel).zipWithIndex.map { case ((state, wakeupVec), srcIdx) => 255 wakeupVec.asUInt.orR | state 256 }).asUInt.andR 257 } 258 259 260 def ShiftLoadDependency(hasIQWakeupGet: CommonIQWakeupBundle)(implicit p: Parameters, params: IssueBlockParams) = { 261 hasIQWakeupGet.shiftedWakeupLoadDependencyByIQVec 262 .zip(hasIQWakeupGet.wakeupLoadDependencyByIQVec) 263 .zip(params.wakeUpInExuSources.map(_.name)).foreach { 264 case ((deps, originalDeps), name) => deps.zip(originalDeps).zipWithIndex.foreach { 265 case ((dep, originalDep), deqPortIdx) => 266 if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx) 267 dep := 1.U 268 else 269 dep := originalDep << 1 270 } 271 } 272 } 273 274 def wakeUpByVf(OH: Vec[Bool])(implicit p: Parameters): Bool = { 275 val allExuParams = p(XSCoreParamsKey).backendParams.allExuParams 276 OH.zip(allExuParams).map{case (oh,e) => 277 if (e.isVfExeUnit) oh else false.B 278 }.reduce(_ || _) 279 } 280 281 def EntryRegCommonConnect(common: CommonWireBundle, hasIQWakeup: Option[CommonIQWakeupBundle], validReg: Bool, entryUpdate: EntryBundle, entryReg: EntryBundle, status: Status, commonIn: CommonInBundle, isEnq: Boolean, isComp: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 282 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 283 val cancelBypassVec = Wire(Vec(params.numRegSrc, Bool())) 284 val srcCancelByLoad = common.srcLoadCancelVec.asUInt.orR 285 val respIssueFail = commonIn.issueResp.valid && RespType.isBlocked(commonIn.issueResp.bits.resp) 286 entryUpdate.status.robIdx := status.robIdx 287 entryUpdate.status.fuType := IQFuType.readFuType(status.fuType, params.getFuCfgs.map(_.fuType)) 288 entryUpdate.status.srcStatus.zip(status.srcStatus).zipWithIndex.foreach { case ((srcStatusNext, srcStatus), srcIdx) => 289 val srcLoadCancel = common.srcLoadCancelVec(srcIdx) 290 val loadTransCancel = common.srcLoadTransCancelVec(srcIdx) 291 val wakeupByWB = common.srcWakeupByWB(srcIdx) 292 val wakeupByIQ = hasIQWakeupGet.srcWakeupByIQ(srcIdx).asUInt.orR && !loadTransCancel 293 val wakeupByIQOH = hasIQWakeupGet.srcWakeupByIQ(srcIdx) 294 val wakeupByMemIQ = wakeupByIQOH.zip(commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _) 295 cancelBypassVec(srcIdx) := (if (isComp) Mux(hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx).asUInt.orR, loadTransCancel, srcLoadCancel) 296 else srcLoadCancel) 297 298 val ignoreOldVd = Wire(Bool()) 299 val vlWakeUpByIntWb = common.vlWakeupByIntWb 300 val vlWakeUpByVfWb = common.vlWakeupByVfWb 301 val isDependOldvd = entryReg.payload.vpu.isDependOldvd 302 val isWritePartVd = entryReg.payload.vpu.isWritePartVd 303 val vta = entryReg.payload.vpu.vta 304 val vma = entryReg.payload.vpu.vma 305 val vm = entryReg.payload.vpu.vm 306 val vlFromIntIsZero = commonIn.vlFromIntIsZero 307 val vlFromIntIsVlmax = commonIn.vlFromIntIsVlmax 308 val vlFromVfIsZero = commonIn.vlFromVfIsZero 309 val vlFromVfIsVlmax = commonIn.vlFromVfIsVlmax 310 val vlIsVlmax = (vlFromIntIsVlmax && vlWakeUpByIntWb) || (vlFromVfIsVlmax && vlWakeUpByVfWb) 311 val vlIsNonZero = (!vlFromIntIsZero && vlWakeUpByIntWb) || (!vlFromVfIsZero && vlWakeUpByVfWb) 312 val ignoreTail = vlIsVlmax && (vm =/= 0.U || vma) && !isWritePartVd 313 val ignoreWhole = (vm =/= 0.U || vma) && vta 314 val srcIsVec = SrcType.isVp(srcStatus.srcType) 315 if (params.numVfSrc > 0 && srcIdx == 2) { 316 /** 317 * the src store the old vd, update it when vl is write back 318 * 1. when the instruction depend on old vd, we cannot set the srctype to imm, we will update the method of uop split to avoid this situation soon 319 * 2. when vl = 0, we cannot set the srctype to imm because the vd keep the old value 320 * 3. when vl = vlmax, we can set srctype to imm when vta is not set 321 */ 322 ignoreOldVd := !VlduType.isFof(entryReg.payload.fuOpType) && srcIsVec && vlIsNonZero && !isDependOldvd && (ignoreTail || ignoreWhole) 323 } else { 324 ignoreOldVd := false.B 325 } 326 327 srcStatusNext.psrc := srcStatus.psrc 328 srcStatusNext.srcType := Mux(ignoreOldVd, SrcType.no, srcStatus.srcType) 329 srcStatusNext.srcState := srcStatus.srcState & !srcLoadCancel | wakeupByWB | wakeupByIQ | ignoreOldVd 330 srcStatusNext.dataSources.value := (if (params.inVfSchd && params.readVfRf && params.hasIQWakeUp) { 331 // Vf / Mem -> Vf 332 MuxCase(srcStatus.dataSources.value, Seq( 333 ignoreOldVd -> DataSource.imm, 334 (wakeupByIQ && wakeupByMemIQ) -> DataSource.bypass2, 335 (wakeupByIQ && !wakeupByMemIQ) -> DataSource.bypass, 336 srcStatus.dataSources.readBypass -> DataSource.bypass2, 337 srcStatus.dataSources.readBypass2 -> DataSource.reg, 338 )) 339 } 340 else if (params.inMemSchd && params.readVfRf && params.hasIQWakeUp) { 341 // Vf / Int -> Mem 342 MuxCase(srcStatus.dataSources.value, Seq( 343 wakeupByIQ -> DataSource.bypass, 344 (srcStatus.dataSources.readBypass && wakeUpByVf(srcStatus.srcWakeUpL1ExuOH.get)) -> DataSource.bypass2, 345 (srcStatus.dataSources.readBypass && !wakeUpByVf(srcStatus.srcWakeUpL1ExuOH.get)) -> DataSource.reg, 346 srcStatus.dataSources.readBypass2 -> DataSource.reg, 347 )) 348 } 349 else { 350 MuxCase(srcStatus.dataSources.value, Seq( 351 ignoreOldVd -> DataSource.imm, 352 wakeupByIQ -> DataSource.bypass, 353 srcStatus.dataSources.readBypass -> DataSource.reg, 354 )) 355 }) 356 if(params.hasIQWakeUp) { 357 ExuOHGen(srcStatusNext.srcWakeUpL1ExuOH.get, wakeupByIQOH, hasIQWakeupGet.srcWakeupL1ExuOH(srcIdx)) 358 srcStatusNext.srcLoadDependency := Mux(wakeupByIQ, 359 Mux1H(wakeupByIQOH, hasIQWakeupGet.shiftedWakeupLoadDependencyByIQVec), 360 common.srcLoadDependencyNext(srcIdx)) 361 } else { 362 srcStatusNext.srcLoadDependency := common.srcLoadDependencyNext(srcIdx) 363 } 364 365 if (params.needReadRegCache) { 366 val wakeupSrcExuWriteRC = wakeupByIQOH.zip(commonIn.wakeUpFromIQ).filter(_._2.bits.params.needWriteRegCache) 367 val wakeupRC = wakeupSrcExuWriteRC.map(_._1).fold(false.B)(_ || _) && SrcType.isXp(srcStatus.srcType) 368 val wakeupRCIdx = Mux1H(wakeupSrcExuWriteRC.map(_._1), wakeupSrcExuWriteRC.map(_._2.bits.rcDest.get)) 369 val replaceRC = wakeupSrcExuWriteRC.map(x => x._2.bits.rfWen && x._2.bits.rcDest.get === srcStatus.regCacheIdx.get).fold(false.B)(_ || _) 370 371 srcStatusNext.useRegCache.get := srcStatus.useRegCache.get && !(srcLoadCancel || replaceRC) || wakeupRC 372 srcStatusNext.regCacheIdx.get := Mux(wakeupRC, wakeupRCIdx, srcStatus.regCacheIdx.get) 373 } 374 } 375 entryUpdate.status.blocked := false.B 376 entryUpdate.status.issued := MuxCase(status.issued, Seq( 377 (commonIn.deqSel && !cancelBypassVec.asUInt.orR) -> true.B, 378 (srcCancelByLoad || respIssueFail) -> false.B, 379 )) 380 entryUpdate.status.firstIssue := commonIn.deqSel || status.firstIssue 381 entryUpdate.status.issueTimer := Mux(commonIn.deqSel, 0.U, Mux(status.issued, Mux(status.issueTimer === "b11".U, status.issueTimer, status.issueTimer + 1.U), "b11".U)) 382 entryUpdate.status.deqPortIdx := Mux(commonIn.deqSel, commonIn.deqPortIdxWrite, Mux(status.issued, status.deqPortIdx, 0.U)) 383 entryUpdate.imm.foreach(_ := entryReg.imm.get) 384 entryUpdate.payload := entryReg.payload 385 if (params.isVecMemIQ) { 386 entryUpdate.status.vecMem.get := entryReg.status.vecMem.get 387 } 388 } 389 390 def CommonOutConnect(commonOut: CommonOutBundle, common: CommonWireBundle, hasIQWakeup: Option[CommonIQWakeupBundle], validReg: Bool, entryUpdate: EntryBundle, entryReg: EntryBundle, status: Status, commonIn: CommonInBundle, isEnq: Boolean, isComp: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 391 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 392 commonOut.valid := validReg 393 commonOut.issued := entryReg.status.issued 394 commonOut.canIssue := (if (isComp) (common.canIssue || hasIQWakeupGet.canIssueBypass) && !common.flushed 395 else common.canIssue && !common.flushed) 396 commonOut.fuType := IQFuType.readFuType(status.fuType, params.getFuCfgs.map(_.fuType)).asUInt 397 commonOut.robIdx := status.robIdx 398 commonOut.dataSource.zipWithIndex.foreach{ case (dataSourceOut, srcIdx) => 399 val wakeupByIQWithoutCancel = hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx).asUInt.orR 400 val wakeupByIQWithoutCancelOH = hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx) 401 val isWakeupByMemIQ = wakeupByIQWithoutCancelOH.zip(commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _) 402 val useRegCache = status.srcStatus(srcIdx).useRegCache.getOrElse(false.B) && status.srcStatus(srcIdx).dataSources.readReg 403 dataSourceOut.value := (if (isComp) 404 if (params.inVfSchd && params.readVfRf && params.hasWakeupFromMem) { 405 MuxCase(status.srcStatus(srcIdx).dataSources.value, Seq( 406 (wakeupByIQWithoutCancel && !isWakeupByMemIQ) -> DataSource.forward, 407 (wakeupByIQWithoutCancel && isWakeupByMemIQ) -> DataSource.bypass, 408 )) 409 } else { 410 MuxCase(status.srcStatus(srcIdx).dataSources.value, Seq( 411 wakeupByIQWithoutCancel -> DataSource.forward, 412 useRegCache -> DataSource.regcache, 413 )) 414 } 415 else { 416 MuxCase(status.srcStatus(srcIdx).dataSources.value, Seq( 417 useRegCache -> DataSource.regcache, 418 )) 419 }) 420 } 421 commonOut.isFirstIssue := !status.firstIssue 422 commonOut.entry.valid := validReg 423 commonOut.entry.bits := entryReg 424 if(isEnq) { 425 commonOut.entry.bits.status := status 426 } 427 commonOut.issueTimerRead := status.issueTimer 428 commonOut.deqPortIdxRead := status.deqPortIdx 429 430 if(params.hasIQWakeUp) { 431 commonOut.srcWakeUpL1ExuOH.get.zipWithIndex.foreach{ case (exuOHOut, srcIdx) => 432 val wakeupByIQWithoutCancelOH = hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx) 433 if (isComp) 434 ExuOHGen(exuOHOut, wakeupByIQWithoutCancelOH, hasIQWakeupGet.srcWakeupL1ExuOH(srcIdx)) 435 else 436 ExuOHGen(exuOHOut, 0.U.asTypeOf(wakeupByIQWithoutCancelOH), hasIQWakeupGet.srcWakeupL1ExuOH(srcIdx)) 437 } 438 } 439 440 val srcLoadDependencyOut = Wire(chiselTypeOf(common.srcLoadDependencyNext)) 441 if(params.hasIQWakeUp) { 442 val wakeupSrcLoadDependencyNext = hasIQWakeupGet.srcWakeupByIQWithoutCancel.map(x => Mux1H(x, hasIQWakeupGet.shiftedWakeupLoadDependencyByIQVec)) 443 srcLoadDependencyOut.zipWithIndex.foreach { case (ldOut, srcIdx) => 444 ldOut := (if (isComp) Mux(hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx).asUInt.orR, 445 wakeupSrcLoadDependencyNext(srcIdx), 446 common.srcLoadDependencyNext(srcIdx)) 447 else common.srcLoadDependencyNext(srcIdx)) 448 } 449 } else { 450 srcLoadDependencyOut := common.srcLoadDependencyNext 451 } 452 commonOut.cancelBypass := VecInit(hasIQWakeupGet.srcWakeupByIQWithoutCancel.zipWithIndex.map{ case (wakeupVec, srcIdx) => 453 if (isComp) Mux(wakeupVec.asUInt.orR, common.srcLoadTransCancelVec(srcIdx), common.srcLoadCancelVec(srcIdx)) 454 else common.srcLoadCancelVec(srcIdx) 455 }).asUInt.orR 456 commonOut.entry.bits.status.srcStatus.map(_.srcLoadDependency).zipWithIndex.foreach { case (ldOut, srcIdx) => 457 ldOut := srcLoadDependencyOut(srcIdx) 458 } 459 460 commonOut.enqReady := common.enqReady 461 commonOut.transEntry.valid := validReg && !common.flushed && !status.issued 462 commonOut.transEntry.bits := entryUpdate 463 // debug 464 commonOut.entryInValid := commonIn.enq.valid 465 commonOut.entryOutDeqValid := validReg && (common.flushed || common.deqSuccess) 466 commonOut.entryOutTransValid := validReg && commonIn.transSel && !(common.flushed || common.deqSuccess) 467 commonOut.perfWakeupByWB := common.srcWakeupByWB.zip(status.srcStatus).map{ case (w, s) => w && SrcState.isBusy(s.srcState) && validReg } 468 if (params.hasIQWakeUp) { 469 commonOut.perfLdCancel.get := common.srcCancelVec.map(_ && validReg) 470 commonOut.perfOg0Cancel.get := hasIQWakeupGet.srcWakeupByIQButCancel.map(_.asUInt.orR && validReg) 471 commonOut.perfWakeupByIQ.get := hasIQWakeupGet.srcWakeupByIQ.map(x => VecInit(x.map(_ && validReg))) 472 } 473 // vecMem 474 if (params.isVecMemIQ) { 475 commonOut.uopIdx.get := entryReg.payload.uopIdx 476 } 477 } 478 479 def EntryVecMemConnect(commonIn: CommonInBundle, common: CommonWireBundle, validReg: Bool, entryReg: EntryBundle, entryRegNext: EntryBundle, entryUpdate: EntryBundle)(implicit p: Parameters, params: IssueBlockParams) = { 480 val fromLsq = commonIn.fromLsq.get 481 val vecMemStatus = entryReg.status.vecMem.get 482 val vecMemStatusUpdate = entryUpdate.status.vecMem.get 483 vecMemStatusUpdate := vecMemStatus 484 485 val isFirstLoad = entryReg.status.vecMem.get.lqIdx === fromLsq.lqDeqPtr 486 487 val isVleff = entryReg.payload.vpu.isVleff 488 // update blocked 489 entryUpdate.status.blocked := !isFirstLoad && isVleff 490 } 491 492 def ExuOHGen(exuOH: Vec[Bool], wakeupByIQOH: Vec[Bool], regSrcExuOH: Vec[Bool])(implicit p: Parameters, params: IssueBlockParams) = { 493 val origExuOH = Wire(chiselTypeOf(exuOH)) 494 when(wakeupByIQOH.asUInt.orR) { 495 origExuOH := Mux1H(wakeupByIQOH, params.wakeUpSourceExuIdx.map(x => MathUtils.IntToOH(x).U(p(XSCoreParamsKey).backendParams.numExu.W)).toSeq).asBools 496 }.otherwise { 497 origExuOH := regSrcExuOH 498 } 499 exuOH := 0.U.asTypeOf(exuOH) 500 params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := origExuOH(x)) 501 } 502 503 object IQFuType { 504 def num = FuType.num 505 506 def apply() = Vec(num, Bool()) 507 508 def readFuType(fuType: Vec[Bool], fus: Seq[FuType.OHType]): Vec[Bool] = { 509 val res = WireDefault(0.U.asTypeOf(fuType)) 510 fus.foreach(x => res(x.id) := fuType(x.id)) 511 res 512 } 513 } 514 515 class EnqDelayInBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 516 //wakeup 517 val wakeUpFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle) 518 val wakeUpFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle) 519 //cancel 520 val srcLoadDependency = Input(Vec(params.numRegSrc, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W)))) 521 val og0Cancel = Input(ExuVec()) 522 val ldCancel = Vec(backendParams.LdExuCnt, Flipped(new LoadCancelIO)) 523 } 524 525 class EnqDelayOutBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 526 val srcWakeUpByWB: Vec[UInt] = Vec(params.numRegSrc, SrcState()) 527 val srcWakeUpByIQ: Vec[UInt] = Vec(params.numRegSrc, SrcState()) 528 val srcWakeUpByIQVec: Vec[Vec[Bool]] = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 529 val srcCancelByLoad: Vec[Bool] = Vec(params.numRegSrc, Bool()) 530 val shiftedWakeupLoadDependencyByIQVec: Vec[Vec[UInt]] = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W))) 531 } 532 533 def EnqDelayWakeupConnect(enqDelayIn: EnqDelayInBundle, enqDelayOut: EnqDelayOutBundle, status: Status, delay: Int)(implicit p: Parameters, params: IssueBlockParams) = { 534 enqDelayOut.srcWakeUpByWB.zipWithIndex.foreach { case (wakeup, i) => 535 wakeup := enqDelayIn.wakeUpFromWB.map{ x => 536 if (i == 3) 537 x.bits.wakeUpV0((status.srcStatus(i).psrc, status.srcStatus(i).srcType), x.valid) 538 else if (i == 4) 539 x.bits.wakeUpVl((status.srcStatus(i).psrc, status.srcStatus(i).srcType), x.valid) 540 else 541 x.bits.wakeUp(Seq((status.srcStatus(i).psrc, status.srcStatus(i).srcType)), x.valid).head 542 }.reduce(_ || _) 543 } 544 545 if (params.hasIQWakeUp) { 546 val wakeupVec: IndexedSeq[IndexedSeq[Bool]] = enqDelayIn.wakeUpFromIQ.map{ x => 547 val psrcSrcTypeVec = status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType) 548 if (params.numRegSrc == 5) { 549 x.bits.wakeUpFromIQ(psrcSrcTypeVec.take(3)) :+ 550 x.bits.wakeUpV0FromIQ(psrcSrcTypeVec(3)) :+ 551 x.bits.wakeUpVlFromIQ(psrcSrcTypeVec(4)) 552 } 553 else 554 x.bits.wakeUpFromIQ(psrcSrcTypeVec) 555 }.toIndexedSeq.transpose 556 val cancelSel = params.wakeUpSourceExuIdx.zip(enqDelayIn.wakeUpFromIQ).map{ case (x, y) => enqDelayIn.og0Cancel(x) && y.bits.is0Lat} 557 enqDelayOut.srcWakeUpByIQVec := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && !cancel })) 558 } else { 559 enqDelayOut.srcWakeUpByIQVec := 0.U.asTypeOf(enqDelayOut.srcWakeUpByIQVec) 560 } 561 562 if (params.hasIQWakeUp) { 563 enqDelayOut.srcWakeUpByIQ.zipWithIndex.foreach { case (wakeup, i) => 564 val ldTransCancel = Mux1H(enqDelayOut.srcWakeUpByIQVec(i), enqDelayIn.wakeUpFromIQ.map(_.bits.loadDependency).map(dp => LoadShouldCancel(Some(dp), enqDelayIn.ldCancel)).toSeq) 565 wakeup := enqDelayOut.srcWakeUpByIQVec(i).asUInt.orR && !ldTransCancel 566 } 567 enqDelayOut.srcCancelByLoad.zipWithIndex.foreach { case (ldCancel, i) => 568 ldCancel := LoadShouldCancel(Some(enqDelayIn.srcLoadDependency(i)), enqDelayIn.ldCancel) 569 } 570 } else { 571 enqDelayOut.srcWakeUpByIQ := 0.U.asTypeOf(enqDelayOut.srcWakeUpByIQ) 572 enqDelayOut.srcCancelByLoad := 0.U.asTypeOf(enqDelayOut.srcCancelByLoad) 573 } 574 575 enqDelayOut.shiftedWakeupLoadDependencyByIQVec.zip(enqDelayIn.wakeUpFromIQ.map(_.bits.loadDependency)) 576 .zip(params.wakeUpInExuSources.map(_.name)).foreach { case ((dps, ldps), name) => 577 dps.zip(ldps).zipWithIndex.foreach { case ((dp, ldp), deqPortIdx) => 578 if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx) 579 dp := 1.U << (delay - 1) 580 else 581 dp := ldp << delay 582 } 583 } 584 } 585} 586