1package xiangshan.backend.issue 2 3import org.chipsalliance.cde.config.Parameters 4import chisel3._ 5import chisel3.util._ 6import utils.{MathUtils, OptionWrapper} 7import utility.HasCircularQueuePtrHelper 8import xiangshan._ 9import xiangshan.backend.Bundles._ 10import xiangshan.backend.datapath.DataSource 11import xiangshan.backend.fu.FuType 12import xiangshan.backend.rob.RobPtr 13import xiangshan.mem.{MemWaitUpdateReq, SqPtr, LqPtr} 14 15object EntryBundles extends HasCircularQueuePtrHelper { 16 17 class Status(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 18 //basic status 19 val robIdx = new RobPtr 20 val fuType = IQFuType() 21 //src status 22 val srcStatus = Vec(params.numRegSrc, new SrcStatus) 23 //issue status 24 val blocked = Bool() 25 val issued = Bool() 26 val firstIssue = Bool() 27 val issueTimer = UInt(2.W) 28 val deqPortIdx = UInt(1.W) 29 //vector mem status 30 val vecMem = OptionWrapper(params.isVecMemIQ, new StatusVecMemPart) 31 32 def srcReady: Bool = { 33 VecInit(srcStatus.map(_.srcState).map(SrcState.isReady)).asUInt.andR 34 } 35 36 def canIssue: Bool = { 37 srcReady && !issued && !blocked 38 } 39 40 def mergedLoadDependency: Vec[UInt] = { 41 srcStatus.map(_.srcLoadDependency).reduce({ 42 case (l: Vec[UInt], r: Vec[UInt]) => VecInit(l.zip(r).map(x => x._1 | x._2)) 43 }: (Vec[UInt], Vec[UInt]) => Vec[UInt]) 44 } 45 } 46 47 class SrcStatus(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 48 val psrc = UInt(params.rdPregIdxWidth.W) 49 val srcType = SrcType() 50 val srcState = SrcState() 51 val dataSources = DataSource() 52 val srcLoadDependency = Vec(LoadPipelineWidth, UInt(3.W)) 53 val srcWakeUpL1ExuOH = OptionWrapper(params.hasIQWakeUp, ExuVec()) 54 } 55 56 class StatusVecMemPart(implicit p:Parameters, params: IssueBlockParams) extends Bundle { 57 val sqIdx = new SqPtr 58 val lqIdx = new LqPtr 59 } 60 61 class EntryDeqRespBundle(implicit p: Parameters, params: IssueBlockParams) extends Bundle { 62 val robIdx = new RobPtr 63 val resp = RespType() 64 val fuType = FuType() 65 val uopIdx = OptionWrapper(params.isVecMemIQ, Output(UopIdx())) 66 } 67 68 object RespType { 69 def apply() = UInt(2.W) 70 71 def isBlocked(resp: UInt) = { 72 resp === block 73 } 74 75 def succeed(resp: UInt) = { 76 resp === success 77 } 78 79 val block = "b00".U 80 val uncertain = "b01".U 81 val success = "b11".U 82 } 83 84 class EntryBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 85 val status = new Status() 86 val imm = OptionWrapper(params.needImm, UInt((params.deqImmTypesMaxLen).W)) 87 val payload = new DynInst() 88 } 89 90 class CommonInBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 91 val flush = Flipped(ValidIO(new Redirect)) 92 val enq = Flipped(ValidIO(new EntryBundle)) 93 //wakeup 94 val wakeUpFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle) 95 val wakeUpFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle) 96 //cancel 97 val og0Cancel = Input(ExuOH(backendParams.numExu)) 98 val og1Cancel = Input(ExuOH(backendParams.numExu)) 99 val ldCancel = Vec(backendParams.LdExuCnt, Flipped(new LoadCancelIO)) 100 //deq sel 101 val deqSel = Input(Bool()) 102 val deqPortIdxWrite = Input(UInt(1.W)) 103 val issueResp = Flipped(ValidIO(new EntryDeqRespBundle)) 104 //trans sel 105 val transSel = Input(Bool()) 106 // vector mem only 107 val fromLsq = OptionWrapper(params.isVecMemIQ, new Bundle { 108 val sqDeqPtr = Input(new SqPtr) 109 val lqDeqPtr = Input(new LqPtr) 110 }) 111 } 112 113 class CommonOutBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 114 //status 115 val valid = Output(Bool()) 116 val canIssue = Output(Bool()) 117 val fuType = Output(FuType()) 118 val robIdx = Output(new RobPtr) 119 val uopIdx = OptionWrapper(params.isVecMemIQ, Output(UopIdx())) 120 //src 121 val dataSource = Vec(params.numRegSrc, Output(DataSource())) 122 val srcLoadDependency = Vec(params.numRegSrc, Output(Vec(LoadPipelineWidth, UInt(3.W)))) 123 val srcWakeUpL1ExuOH = OptionWrapper(params.hasIQWakeUp, Vec(params.numRegSrc, Output(ExuVec()))) 124 //deq 125 val isFirstIssue = Output(Bool()) 126 val entry = ValidIO(new EntryBundle) 127 val deqPortIdxRead = Output(UInt(1.W)) 128 val issueTimerRead = Output(UInt(2.W)) 129 //trans 130 val enqReady = Output(Bool()) 131 val transEntry = ValidIO(new EntryBundle) 132 // debug 133 val entryInValid = Output(Bool()) 134 val entryOutDeqValid = Output(Bool()) 135 val entryOutTransValid = Output(Bool()) 136 val perfLdCancel = OptionWrapper(params.hasIQWakeUp, Output(Vec(params.numRegSrc, Bool()))) 137 val perfOg0Cancel = OptionWrapper(params.hasIQWakeUp, Output(Vec(params.numRegSrc, Bool()))) 138 val perfWakeupByWB = Output(Vec(params.numRegSrc, Bool())) 139 val perfWakeupByIQ = OptionWrapper(params.hasIQWakeUp, Output(Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())))) 140 } 141 142 class CommonWireBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 143 val validRegNext = Bool() 144 val flushed = Bool() 145 val clear = Bool() 146 val canIssue = Bool() 147 val enqReady = Bool() 148 val deqSuccess = Bool() 149 val srcWakeup = Vec(params.numRegSrc, Bool()) 150 val srcWakeupByWB = Vec(params.numRegSrc, Bool()) 151 val srcLoadDependencyOut = Vec(params.numRegSrc, Vec(LoadPipelineWidth, UInt(3.W))) 152 val srcCancelVec = Vec(params.numRegSrc, Bool()) 153 val srcLoadCancelVec = Vec(params.numRegSrc, Bool()) 154 } 155 156 def CommonWireConnect(common: CommonWireBundle, hasIQWakeup: Option[CommonIQWakeupBundle], validReg: Bool, status: Status, commonIn: CommonInBundle, isEnq: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 157 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 158 common.flushed := status.robIdx.needFlush(commonIn.flush) 159 common.deqSuccess := commonIn.issueResp.valid && RespType.succeed(commonIn.issueResp.bits.resp) && !common.srcLoadCancelVec.asUInt.orR 160 common.srcWakeup := common.srcWakeupByWB.zip(hasIQWakeupGet.srcWakeupByIQ).map { case (x, y) => x || y.asUInt.orR } 161 common.srcWakeupByWB := commonIn.wakeUpFromWB.map(bundle => bundle.bits.wakeUp(status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType), bundle.valid)).transpose.map(x => VecInit(x.toSeq).asUInt.orR).toSeq 162 common.canIssue := validReg && status.canIssue 163 common.enqReady := !validReg || common.clear 164 common.clear := common.flushed || common.deqSuccess || commonIn.transSel 165 common.srcCancelVec.zip(common.srcLoadCancelVec).zip(hasIQWakeupGet.srcWakeupByIQWithoutCancel).zipWithIndex.foreach { case (((srcCancel, srcLoadCancel), wakeUpByIQVec), srcIdx) => 166 val ldTransCancel = if(params.hasIQWakeUp) Mux1H(wakeUpByIQVec, hasIQWakeupGet.wakeupLoadDependencyByIQVec.map(dep => LoadShouldCancel(Some(dep), commonIn.ldCancel))) else false.B 167 srcLoadCancel := LoadShouldCancel(Some(status.srcStatus(srcIdx).srcLoadDependency), commonIn.ldCancel) 168 srcCancel := srcLoadCancel || ldTransCancel 169 } 170 common.srcLoadDependencyOut.zip(hasIQWakeupGet.srcWakeupByIQ).zip(status.srcStatus.map(_.srcLoadDependency)).foreach { 171 case ((loadDependencyOut, wakeUpByIQVec), loadDependency) => 172 if(params.hasIQWakeUp) { 173 loadDependencyOut := Mux(wakeUpByIQVec.asUInt.orR, Mux1H(wakeUpByIQVec, hasIQWakeupGet.shiftedWakeupLoadDependencyByIQBypassVec), loadDependency) 174 } else { 175 loadDependencyOut := loadDependency 176 } 177 178 } 179 if(isEnq) { 180 common.validRegNext := Mux(commonIn.enq.valid && common.enqReady, true.B, Mux(common.clear, false.B, validReg)) 181 } else { 182 common.validRegNext := Mux(commonIn.enq.valid, true.B, Mux(common.clear, false.B, validReg)) 183 } 184 } 185 186 class CommonIQWakeupBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 187 val srcWakeupByIQ = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 188 val srcWakeupByIQWithoutCancel = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 189 val srcWakeupByIQButCancel = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 190 val regSrcWakeupL1ExuOH = Vec(params.numRegSrc, ExuVec()) 191 val srcWakeupL1ExuOHOut = Vec(params.numRegSrc, ExuVec()) 192 val wakeupLoadDependencyByIQVec = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))) 193 val shiftedWakeupLoadDependencyByIQVec = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))) 194 val shiftedWakeupLoadDependencyByIQBypassVec = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))) 195 val cancelVec = Vec(params.numRegSrc, Bool()) 196 val canIssueBypass = Bool() 197 } 198 199 def CommonIQWakeupConnect(common: CommonWireBundle, hasIQWakeupGet: CommonIQWakeupBundle, validReg: Bool, status: Status, commonIn: CommonInBundle, isEnq: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 200 val wakeupVec: Seq[Seq[Bool]] = commonIn.wakeUpFromIQ.map((bundle: ValidIO[IssueQueueIQWakeUpBundle]) => 201 bundle.bits.wakeUpFromIQ(status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType)) 202 ).toSeq.transpose 203 val cancelSel = params.wakeUpSourceExuIdx.zip(commonIn.wakeUpFromIQ).map { case (x, y) => commonIn.og0Cancel(x) && y.bits.is0Lat } 204 205 hasIQWakeupGet.cancelVec := common.srcCancelVec 206 hasIQWakeupGet.srcWakeupByIQ := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && !cancel })) 207 hasIQWakeupGet.srcWakeupByIQButCancel := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && cancel })) 208 hasIQWakeupGet.srcWakeupByIQWithoutCancel := wakeupVec.map(x => VecInit(x)) 209 hasIQWakeupGet.wakeupLoadDependencyByIQVec := commonIn.wakeUpFromIQ.map(_.bits.loadDependency).toSeq 210 hasIQWakeupGet.regSrcWakeupL1ExuOH.zip(status.srcStatus.map(_.srcWakeUpL1ExuOH.get)).foreach { 211 case (exuOH, regExuOH) => 212 exuOH := 0.U.asTypeOf(exuOH) 213 params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := regExuOH(x)) 214 } 215 hasIQWakeupGet.srcWakeupL1ExuOHOut.zip(hasIQWakeupGet.srcWakeupByIQWithoutCancel).zip(common.srcWakeup).zipWithIndex.foreach { 216 case (((exuOH: Vec[Bool], wakeUpByIQOH: Vec[Bool]), wakeUp: Bool), srcIdx) => 217 if(isEnq) { 218 ExuOHGen(exuOH, wakeUpByIQOH, wakeUp, status.srcStatus(srcIdx).srcWakeUpL1ExuOH.get) 219 } else { 220 ExuOHGen(exuOH, wakeUpByIQOH, wakeUp, hasIQWakeupGet.regSrcWakeupL1ExuOH(srcIdx)) 221 } 222 } 223 hasIQWakeupGet.canIssueBypass := validReg && !status.issued && !status.blocked && 224 VecInit(status.srcStatus.map(_.srcState).zip(hasIQWakeupGet.srcWakeupByIQWithoutCancel).zipWithIndex.map { case ((state, wakeupVec), srcIdx) => 225 wakeupVec.asUInt.orR | state 226 }).asUInt.andR 227 } 228 229 230 def ShiftLoadDependency(hasIQWakeupGet: CommonIQWakeupBundle)(implicit p: Parameters, params: IssueBlockParams) = { 231 hasIQWakeupGet.shiftedWakeupLoadDependencyByIQVec 232 .zip(hasIQWakeupGet.wakeupLoadDependencyByIQVec) 233 .zip(params.wakeUpInExuSources.map(_.name)).foreach { 234 case ((deps, originalDeps), name) => deps.zip(originalDeps).zipWithIndex.foreach { 235 case ((dep, originalDep), deqPortIdx) => 236 if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx) 237 dep := 2.U 238 else 239 dep := originalDep << 1 240 } 241 } 242 hasIQWakeupGet.shiftedWakeupLoadDependencyByIQBypassVec 243 .zip(hasIQWakeupGet.wakeupLoadDependencyByIQVec) 244 .zip(params.wakeUpInExuSources.map(_.name)).foreach { 245 case ((deps, originalDeps), name) => deps.zip(originalDeps).zipWithIndex.foreach { 246 case ((dep, originalDep), deqPortIdx) => 247 if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx) 248 dep := 1.U 249 else 250 dep := originalDep 251 } 252 } 253 } 254 255 def wakeUpByVf(OH: Vec[Bool])(implicit p: Parameters): Bool = { 256 val allExuParams = p(XSCoreParamsKey).backendParams.allExuParams 257 OH.zip(allExuParams).map{case (oh,e) => 258 if (e.isVfExeUnit) oh else false.B 259 }.reduce(_ || _) 260 } 261 262 def EntryRegCommonConnect(common: CommonWireBundle, hasIQWakeup: Option[CommonIQWakeupBundle], validReg: Bool, entryUpdate: EntryBundle, entryReg: EntryBundle, status: Status, commonIn: CommonInBundle, isEnq: Boolean)(implicit p: Parameters, params: IssueBlockParams) = { 263 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 264 val cancelByLd = common.srcCancelVec.asUInt.orR 265 val cancelWhenWakeup = VecInit(hasIQWakeupGet.srcWakeupByIQButCancel.map(_.asUInt.orR)).asUInt.orR 266 val respIssueFail = commonIn.issueResp.valid && RespType.isBlocked(commonIn.issueResp.bits.resp) 267 val srcWakeupExuOH = if(isEnq) status.srcStatus.map(_.srcWakeUpL1ExuOH.getOrElse(0.U.asTypeOf(ExuVec()))) else hasIQWakeupGet.regSrcWakeupL1ExuOH 268 entryUpdate.status.robIdx := status.robIdx 269 entryUpdate.status.fuType := IQFuType.readFuType(status.fuType, params.getFuCfgs.map(_.fuType)) 270 entryUpdate.status.srcStatus.zip(status.srcStatus).zipWithIndex.foreach { case ((srcStatusNext, srcStatus), srcIdx) => 271 val cancel = common.srcCancelVec(srcIdx) 272 val wakeupByIQ = hasIQWakeupGet.srcWakeupByIQ(srcIdx).asUInt.orR 273 val wakeupByIQOH = hasIQWakeupGet.srcWakeupByIQ(srcIdx) 274 val wakeup = common.srcWakeup(srcIdx) 275 srcStatusNext.psrc := srcStatus.psrc 276 srcStatusNext.srcType := srcStatus.srcType 277 srcStatusNext.srcState := Mux(cancel, false.B, wakeup | srcStatus.srcState) 278 srcStatusNext.dataSources.value := (if (params.inVfSchd && params.readVfRf && params.hasIQWakeUp) { 279 // Vf / Mem -> Vf 280 val isWakeupByMemIQ = wakeupByIQOH.zip(commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _) 281 MuxCase(srcStatus.dataSources.value, Seq( 282 (wakeupByIQ && isWakeupByMemIQ) -> DataSource.bypass2, 283 (wakeupByIQ && !isWakeupByMemIQ) -> DataSource.bypass, 284 srcStatus.dataSources.readBypass -> DataSource.bypass2, 285 srcStatus.dataSources.readBypass2 -> DataSource.reg, 286 )) 287 } 288 else if (params.inMemSchd && params.readVfRf && params.hasIQWakeUp) { 289 // Vf / Int -> Mem 290 MuxCase(srcStatus.dataSources.value, Seq( 291 wakeupByIQ -> DataSource.bypass, 292 (srcStatus.dataSources.readBypass && wakeUpByVf(srcStatus.srcWakeUpL1ExuOH.get)) -> DataSource.bypass2, 293 (srcStatus.dataSources.readBypass && !wakeUpByVf(srcStatus.srcWakeUpL1ExuOH.get)) -> DataSource.reg, 294 srcStatus.dataSources.readBypass2 -> DataSource.reg, 295 )) 296 } 297 else { 298 MuxCase(srcStatus.dataSources.value, Seq( 299 wakeupByIQ -> DataSource.bypass, 300 srcStatus.dataSources.readBypass -> DataSource.reg, 301 )) 302 }) 303 if(params.hasIQWakeUp) { 304 ExuOHGen(srcStatusNext.srcWakeUpL1ExuOH.get, wakeupByIQOH, wakeup, srcWakeupExuOH(srcIdx)) 305 srcStatusNext.srcLoadDependency := 306 Mux(wakeup, 307 Mux1H(wakeupByIQOH, hasIQWakeupGet.shiftedWakeupLoadDependencyByIQVec), 308 Mux(validReg && srcStatus.srcLoadDependency.asUInt.orR, VecInit(srcStatus.srcLoadDependency.map(i => i(i.getWidth - 2, 0) << 1)), srcStatus.srcLoadDependency)) 309 } else { 310 srcStatusNext.srcLoadDependency := Mux(validReg && srcStatus.srcLoadDependency.asUInt.orR, VecInit(srcStatus.srcLoadDependency.map(i => i(i.getWidth - 2, 0) << 1)), srcStatus.srcLoadDependency) 311 } 312 } 313 entryUpdate.status.blocked := false.B 314 entryUpdate.status.issued := MuxCase(status.issued, Seq( 315 (cancelByLd || cancelWhenWakeup || respIssueFail) -> false.B, 316 commonIn.deqSel -> true.B, 317 !status.srcReady -> false.B, 318 )) 319 entryUpdate.status.firstIssue := commonIn.deqSel || status.firstIssue 320 entryUpdate.status.issueTimer := Mux(commonIn.deqSel, 0.U, Mux(status.issued, status.issueTimer + 1.U, "b11".U)) 321 entryUpdate.status.deqPortIdx := Mux(commonIn.deqSel, commonIn.deqPortIdxWrite, Mux(status.issued, status.deqPortIdx, 0.U)) 322 entryUpdate.imm.foreach(_ := entryReg.imm.get) 323 entryUpdate.payload := entryReg.payload 324 if (params.isVecMemIQ) { 325 entryUpdate.status.vecMem.get := entryReg.status.vecMem.get 326 } 327 } 328 329 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) = { 330 val hasIQWakeupGet = hasIQWakeup.getOrElse(0.U.asTypeOf(new CommonIQWakeupBundle)) 331 val srcWakeupExuOH = if(isEnq) status.srcStatus.map(_.srcWakeUpL1ExuOH.getOrElse(0.U.asTypeOf(ExuVec()))) else hasIQWakeupGet.regSrcWakeupL1ExuOH 332 commonOut.valid := validReg 333 commonOut.canIssue := (if (isComp) (common.canIssue || hasIQWakeupGet.canIssueBypass) && !common.flushed 334 else common.canIssue && !common.flushed) 335 commonOut.fuType := IQFuType.readFuType(status.fuType, params.getFuCfgs.map(_.fuType)).asUInt 336 commonOut.robIdx := status.robIdx 337 commonOut.dataSource.zipWithIndex.foreach{ case (dataSourceOut, srcIdx) => 338 val wakeupByIQWithoutCancel = hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx).asUInt.orR 339 val wakeupByIQWithoutCancelOH = hasIQWakeupGet.srcWakeupByIQWithoutCancel(srcIdx) 340 val isWakeupByMemIQ = wakeupByIQWithoutCancelOH.zip(commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _) 341 dataSourceOut.value := Mux(wakeupByIQWithoutCancel, 342 if (params.inVfSchd && params.readVfRf && params.hasWakeupFromMem) Mux(isWakeupByMemIQ, DataSource.bypass, DataSource.forward) else DataSource.forward, 343 status.srcStatus(srcIdx).dataSources.value) 344 } 345 commonOut.isFirstIssue := !status.firstIssue 346 commonOut.entry.valid := validReg 347 commonOut.entry.bits := entryReg 348 if(isEnq) { 349 commonOut.entry.bits.status := status 350 } 351 commonOut.issueTimerRead := status.issueTimer 352 commonOut.deqPortIdxRead := status.deqPortIdx 353 if(params.hasIQWakeUp) { 354 val wakeupSrcLoadDependency = hasIQWakeupGet.srcWakeupByIQWithoutCancel.map(x => Mux1H(x, hasIQWakeupGet.wakeupLoadDependencyByIQVec)) 355 commonOut.srcWakeUpL1ExuOH.get := (if (isComp) Mux(hasIQWakeupGet.canIssueBypass && !common.canIssue, hasIQWakeupGet.srcWakeupL1ExuOHOut, VecInit(srcWakeupExuOH)) 356 else VecInit(srcWakeupExuOH)) 357 commonOut.srcLoadDependency.zipWithIndex.foreach { case (srcLoadDependencyOut, srcIdx) => 358 srcLoadDependencyOut := (if (isComp) Mux(hasIQWakeupGet.canIssueBypass && !common.canIssue, 359 VecInit(status.srcStatus(srcIdx).srcLoadDependency.zip(wakeupSrcLoadDependency(srcIdx)).map(x => x._1 | x._2)), 360 status.srcStatus(srcIdx).srcLoadDependency) 361 else status.srcStatus(srcIdx).srcLoadDependency) 362 } 363 } else { 364 commonOut.srcLoadDependency.zipWithIndex.foreach { case (srcLoadDependencyOut, srcIdx) => 365 srcLoadDependencyOut := status.srcStatus(srcIdx).srcLoadDependency 366 } 367 } 368 commonOut.entry.bits.status.srcStatus.map(_.srcLoadDependency).zipWithIndex.foreach { case (srcLoadDependencyOut, srcIdx) => 369 srcLoadDependencyOut := (if (isComp) Mux(hasIQWakeupGet.canIssueBypass && !common.canIssue, 370 common.srcLoadDependencyOut(srcIdx), 371 status.srcStatus(srcIdx).srcLoadDependency) 372 else status.srcStatus(srcIdx).srcLoadDependency) 373 } 374 commonOut.enqReady := common.enqReady 375 commonOut.transEntry.valid := validReg && !common.flushed && !common.deqSuccess 376 commonOut.transEntry.bits := entryUpdate 377 // debug 378 commonOut.entryInValid := commonIn.enq.valid 379 commonOut.entryOutDeqValid := validReg && (common.flushed || common.deqSuccess) 380 commonOut.entryOutTransValid := validReg && commonIn.transSel && !(common.flushed || common.deqSuccess) 381 commonOut.perfWakeupByWB := common.srcWakeupByWB.zip(status.srcStatus).map{ case (w, s) => w && SrcState.isBusy(s.srcState) && validReg } 382 if (params.hasIQWakeUp) { 383 commonOut.perfLdCancel.get := hasIQWakeupGet.cancelVec.map(_ && validReg) 384 commonOut.perfOg0Cancel.get := hasIQWakeupGet.srcWakeupByIQButCancel.map(_.asUInt.orR && validReg) 385 commonOut.perfWakeupByIQ.get := hasIQWakeupGet.srcWakeupByIQ.map(x => VecInit(x.map(_ && validReg))) 386 } 387 // vecMem 388 if (params.isVecMemIQ) { 389 commonOut.uopIdx.get := entryReg.payload.uopIdx 390 } 391 } 392 393 def EntryVecMemConnect(commonIn: CommonInBundle, common: CommonWireBundle, validReg: Bool, entryReg: EntryBundle, entryRegNext: EntryBundle, entryUpdate: EntryBundle)(implicit p: Parameters, params: IssueBlockParams) = { 394 val fromLsq = commonIn.fromLsq.get 395 val vecMemStatus = entryReg.status.vecMem.get 396 val vecMemStatusUpdate = entryUpdate.status.vecMem.get 397 vecMemStatusUpdate := vecMemStatus 398 399 val isLsqHead = { 400 entryReg.status.vecMem.get.lqIdx <= fromLsq.lqDeqPtr && 401 entryReg.status.vecMem.get.sqIdx <= fromLsq.sqDeqPtr 402 } 403 404 // update blocked 405 entryUpdate.status.blocked := !isLsqHead 406 } 407 408 def ExuOHGen(exuOH: Vec[Bool], wakeupByIQOH: Vec[Bool], wakeup: Bool, regSrcExuOH: Vec[Bool])(implicit p: Parameters, params: IssueBlockParams) = { 409 val origExuOH = 0.U.asTypeOf(exuOH) 410 when(wakeupByIQOH.asUInt.orR) { 411 origExuOH := Mux1H(wakeupByIQOH, params.wakeUpSourceExuIdx.map(x => MathUtils.IntToOH(x).U(p(XSCoreParamsKey).backendParams.numExu.W)).toSeq).asBools 412 }.otherwise { 413 origExuOH := regSrcExuOH 414 } 415 exuOH := 0.U.asTypeOf(exuOH) 416 params.wakeUpSourceExuIdx.foreach(x => exuOH(x) := origExuOH(x)) 417 } 418 419 object IQFuType { 420 def num = FuType.num 421 422 def apply() = Vec(num, Bool()) 423 424 def readFuType(fuType: Vec[Bool], fus: Seq[FuType.OHType]): Vec[Bool] = { 425 val res = 0.U.asTypeOf(fuType) 426 fus.foreach(x => res(x.id) := fuType(x.id)) 427 res 428 } 429 } 430 431 class EnqDelayInBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 432 //wakeup 433 val wakeUpFromWB: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = Flipped(params.genWBWakeUpSinkValidBundle) 434 val wakeUpFromIQ: MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = Flipped(params.genIQWakeUpSinkValidBundle) 435 //cancel 436 val og0Cancel = Input(ExuOH(backendParams.numExu)) 437 val ldCancel = Vec(backendParams.LdExuCnt, Flipped(new LoadCancelIO)) 438 } 439 440 class EnqDelayOutBundle(implicit p: Parameters, params: IssueBlockParams) extends XSBundle { 441 val srcWakeUpByWB: Vec[UInt] = Vec(params.numRegSrc, SrcState()) 442 val srcWakeUpByIQ: Vec[UInt] = Vec(params.numRegSrc, SrcState()) 443 val srcWakeUpByIQVec: Vec[Vec[Bool]] = Vec(params.numRegSrc, Vec(params.numWakeupFromIQ, Bool())) 444 val shiftedWakeupLoadDependencyByIQVec: Vec[Vec[UInt]] = Vec(params.numWakeupFromIQ, Vec(LoadPipelineWidth, UInt(3.W))) 445 } 446 447 def EnqDelayWakeupConnect(enqDelayIn: EnqDelayInBundle, enqDelayOut: EnqDelayOutBundle, status: Status, delay: Int)(implicit p: Parameters, params: IssueBlockParams) = { 448 enqDelayOut.srcWakeUpByWB.zipWithIndex.foreach { case (wakeup, i) => 449 wakeup := enqDelayIn.wakeUpFromWB.map(x => x.bits.wakeUp(Seq((status.srcStatus(i).psrc, status.srcStatus(i).srcType)), x.valid).head 450 ).reduce(_ || _) 451 } 452 453 if (params.hasIQWakeUp) { 454 val wakeupVec: IndexedSeq[IndexedSeq[Bool]] = enqDelayIn.wakeUpFromIQ.map( x => 455 x.bits.wakeUpFromIQ(status.srcStatus.map(_.psrc) zip status.srcStatus.map(_.srcType)) 456 ).toIndexedSeq.transpose 457 val cancelSel = params.wakeUpSourceExuIdx.zip(enqDelayIn.wakeUpFromIQ).map{ case (x, y) => enqDelayIn.og0Cancel(x) && y.bits.is0Lat} 458 enqDelayOut.srcWakeUpByIQVec := wakeupVec.map(x => VecInit(x.zip(cancelSel).map { case (wakeup, cancel) => wakeup && !cancel })) 459 } else { 460 enqDelayOut.srcWakeUpByIQVec := 0.U.asTypeOf(enqDelayOut.srcWakeUpByIQVec) 461 } 462 463 if (params.hasIQWakeUp) { 464 enqDelayOut.srcWakeUpByIQ.zipWithIndex.foreach { case (wakeup, i) => 465 val ldTransCancel = Mux1H(enqDelayOut.srcWakeUpByIQVec(i), enqDelayIn.wakeUpFromIQ.map(_.bits.loadDependency).map(dp => LoadShouldCancel(Some(dp), enqDelayIn.ldCancel)).toSeq) 466 wakeup := enqDelayOut.srcWakeUpByIQVec(i).asUInt.orR && !ldTransCancel 467 } 468 } else { 469 enqDelayOut.srcWakeUpByIQ := 0.U.asTypeOf(enqDelayOut.srcWakeUpByIQ) 470 } 471 472 enqDelayOut.shiftedWakeupLoadDependencyByIQVec.zip(enqDelayIn.wakeUpFromIQ.map(_.bits.loadDependency)) 473 .zip(params.wakeUpInExuSources.map(_.name)).foreach { case ((dps, ldps), name) => 474 dps.zip(ldps).zipWithIndex.foreach { case ((dp, ldp), deqPortIdx) => 475 if (params.backendParam.getLdExuIdx(params.backendParam.allExuParams.find(_.name == name).get) == deqPortIdx) 476 dp := 1.U << delay 477 else 478 dp := ldp << delay 479 } 480 } 481 } 482} 483