1package xiangshan.backend.issue 2 3import org.chipsalliance.cde.config.Parameters 4import chisel3._ 5import chisel3.util._ 6import utils.SeqUtils 7import xiangshan.backend.BackendParams 8import xiangshan.backend.Bundles._ 9import xiangshan.backend.datapath.DataConfig.DataConfig 10import xiangshan.backend.datapath.WbConfig.{IntWB, PregWB, VfWB} 11import xiangshan.backend.datapath.{WakeUpConfig, WakeUpSource} 12import xiangshan.backend.exu.{ExeUnit, ExeUnitParams} 13import xiangshan.backend.fu.{FuConfig, FuType} 14import xiangshan.SelImm 15 16case class IssueBlockParams( 17 // top down 18 private val exuParams: Seq[ExeUnitParams], 19 val numEntries : Int, 20 numEnq : Int, 21 numComp : Int, 22 numDeqOutside : Int = 0, 23 numWakeupFromOthers : Int = 0, 24 XLEN : Int = 64, 25 VLEN : Int = 128, 26 vaddrBits : Int = 39, 27 // calculate in scheduler 28 var idxInSchBlk : Int = 0, 29)( 30 implicit 31 val schdType: SchedulerType, 32) { 33 var backendParam: BackendParams = null 34 35 val exuBlockParams: Seq[ExeUnitParams] = exuParams.filterNot(_.fakeUnit) 36 37 val allExuParams = exuParams 38 39 def updateIdx(idx: Int): Unit = { 40 this.idxInSchBlk = idx 41 } 42 43 def inMemSchd: Boolean = schdType == MemScheduler() 44 45 def inIntSchd: Boolean = schdType == IntScheduler() 46 47 def inVfSchd: Boolean = schdType == VfScheduler() 48 49 def isMemAddrIQ: Boolean = inMemSchd && (LduCnt > 0 || StaCnt > 0 || VlduCnt > 0 || VstaCnt > 0 || HyuCnt > 0) 50 51 def isLdAddrIQ: Boolean = inMemSchd && LduCnt > 0 52 53 def isStAddrIQ: Boolean = inMemSchd && StaCnt > 0 54 55 def isHyAddrIQ: Boolean = inMemSchd && HyuCnt > 0 56 57 def isVecMemAddrIQ: Boolean = inMemSchd && (VlduCnt > 0 || VstaCnt > 0) 58 59 def isVecLdAddrIQ: Boolean = inMemSchd && VlduCnt > 0 60 61 def isVecStAddrIQ: Boolean = inMemSchd && VstaCnt > 0 62 63 def isVecStDataIQ: Boolean = inMemSchd && VstdCnt > 0 64 65 def isVecMemIQ: Boolean = (isVecLdAddrIQ || isVecStAddrIQ || isVecStDataIQ) 66 67 def numExu: Int = exuBlockParams.count(!_.fakeUnit) 68 69 def numIntSrc: Int = exuBlockParams.map(_.numIntSrc).max 70 71 def numFpSrc: Int = exuBlockParams.map(_.numFpSrc).max 72 73 def numVecSrc: Int = exuBlockParams.map(_.numVecSrc).max 74 75 def numVfSrc: Int = exuBlockParams.map(_.numVfSrc).max 76 77 def numRegSrc: Int = exuBlockParams.map(_.numRegSrc).max 78 79 def numSrc: Int = exuBlockParams.map(_.numSrc).max 80 81 def readIntRf: Boolean = numIntSrc > 0 82 83 def readFpRf: Boolean = numFpSrc > 0 84 85 def readVecRf: Boolean = numVecSrc > 0 86 87 def readVfRf: Boolean = numVfSrc > 0 88 89 def writeIntRf: Boolean = exuBlockParams.map(_.writeIntRf).reduce(_ || _) 90 91 def writeFpRf: Boolean = exuBlockParams.map(_.writeFpRf).reduce(_ || _) 92 93 def writeVecRf: Boolean = exuBlockParams.map(_.writeVecRf).reduce(_ || _) 94 95 def exceptionOut: Seq[Int] = exuBlockParams.map(_.exceptionOut).reduce(_ ++ _).distinct.sorted 96 97 def hasLoadError: Boolean = exuBlockParams.map(_.hasLoadError).reduce(_ || _) 98 99 def flushPipe: Boolean = exuBlockParams.map(_.flushPipe).reduce(_ || _) 100 101 def replayInst: Boolean = exuBlockParams.map(_.replayInst).reduce(_ || _) 102 103 def trigger: Boolean = exuBlockParams.map(_.trigger).reduce(_ || _) 104 105 def needExceptionGen: Boolean = exceptionOut.nonEmpty || flushPipe || replayInst || trigger 106 107 def needPc: Boolean = JmpCnt + BrhCnt + FenceCnt > 0 108 109 def needSrcFrm: Boolean = exuBlockParams.map(_.needSrcFrm).reduce(_ || _) 110 111 def numPcReadPort: Int = (if (needPc) 1 else 0) * numEnq 112 113 def numWriteIntRf: Int = exuBlockParams.count(_.writeIntRf) 114 115 def numWriteFpRf: Int = exuBlockParams.count(_.writeFpRf) 116 117 def numWriteVecRf: Int = exuBlockParams.count(_.writeVecRf) 118 119 def numWriteVfRf: Int = exuBlockParams.count(_.writeVfRf) 120 121 def numNoDataWB: Int = exuBlockParams.count(_.hasNoDataWB) 122 123 def dataBitsMax: Int = if (numVecSrc > 0) VLEN else XLEN 124 125 def numDeq: Int = numDeqOutside + exuBlockParams.length 126 127 def numSimp: Int = numEntries - numEnq - numComp 128 129 def isAllComp: Boolean = numComp == (numEntries - numEnq) 130 131 def isAllSimp: Boolean = numComp == 0 132 133 def hasCompAndSimp: Boolean = !(isAllComp || isAllSimp) 134 135 def JmpCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.jmp)).sum 136 137 def BrhCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.brh)).sum 138 139 def I2fCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.i2f)).sum 140 141 def CsrCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.csr)).sum 142 143 def AluCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.alu)).sum 144 145 def MulCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.mul)).sum 146 147 def DivCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.div)).sum 148 149 def FenceCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.fence)).sum 150 151 def BkuCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.bku)).sum 152 153 def VsetCnt: Int = exuBlockParams.map(_.fuConfigs.count(x => x.fuType == FuType.vsetiwi || x.fuType == FuType.vsetiwf || x.fuType == FuType.vsetfwf)).sum 154 155 def FmacCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.fmac)).sum 156 157 def FmiscCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.fmisc)).sum 158 159 def fDivSqrtCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.fDivSqrt)).sum 160 161 def LduCnt: Int = exuBlockParams.count(x => x.hasLoadFu && !x.hasStoreAddrFu) 162 163 def StaCnt: Int = exuBlockParams.count(x => !x.hasLoadFu && x.hasStoreAddrFu) 164 165 def MouCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.mou)).sum 166 167 def StdCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.name == "std")).sum 168 169 def HyuCnt: Int = exuBlockParams.count(_.hasHyldaFu) // only count hylda, since it equals to hysta 170 171 def LdExuCnt = LduCnt + HyuCnt 172 173 def VipuCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.vipu)).sum 174 175 def VfpuCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.vfpu)).sum 176 177 def VlduCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.vldu)).sum 178 179 def VstuCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.fuType == FuType.vstu)).sum 180 181 def VstaCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.name == "vsta")).sum 182 183 def VstdCnt: Int = exuBlockParams.map(_.fuConfigs.count(_.name == "vstd")).sum 184 185 def numRedirect: Int = exuBlockParams.count(_.hasRedirect) 186 187 /** 188 * Get the regfile type that this issue queue need to read 189 */ 190 def pregReadSet: Set[DataConfig] = exuBlockParams.map(_.pregRdDataCfgSet).fold(Set())(_ union _) 191 192 /** 193 * Get the regfile type that this issue queue need to read 194 */ 195 def pregWriteSet: Set[DataConfig] = exuBlockParams.map(_.pregWbDataCfgSet).fold(Set())(_ union _) 196 197 /** 198 * Get the max width of psrc 199 */ 200 def rdPregIdxWidth = { 201 this.pregReadSet.map(cfg => backendParam.getPregParams(cfg).addrWidth).fold(0)(_ max _) 202 } 203 204 /** 205 * Get the max width of pdest 206 */ 207 def wbPregIdxWidth = { 208 this.pregWriteSet.map(cfg => backendParam.getPregParams(cfg).addrWidth).fold(0)(_ max _) 209 } 210 211 def iqWakeUpSourcePairs: Seq[WakeUpConfig] = exuBlockParams.flatMap(_.iqWakeUpSourcePairs) 212 213 /** Get exu source wake up 214 * @todo replace with 215 * exuBlockParams 216 * .flatMap(_.iqWakeUpSinkPairs) 217 * .map(_.source) 218 * .distinctBy(_.name) 219 * when xiangshan is updated to 2.13.11 220 */ 221 def wakeUpInExuSources: Seq[WakeUpSource] = { 222 SeqUtils.distinctBy( 223 exuBlockParams 224 .flatMap(_.iqWakeUpSinkPairs) 225 .map(_.source) 226 )(_.name) 227 } 228 229 def wakeUpOutExuSources: Seq[WakeUpSource] = { 230 SeqUtils.distinctBy( 231 exuBlockParams 232 .flatMap(_.iqWakeUpSourcePairs) 233 .map(_.source) 234 )(_.name) 235 } 236 237 def wakeUpToExuSinks = exuBlockParams 238 .flatMap(_.iqWakeUpSourcePairs) 239 .map(_.sink).distinct 240 241 def numWakeupToIQ: Int = wakeUpInExuSources.size 242 243 def numWakeupFromIQ: Int = wakeUpInExuSources.size 244 245 def numAllWakeUp: Int = numWakeupFromWB + numWakeupFromIQ + numWakeupFromOthers 246 247 def numWakeupFromWB = { 248 val pregSet = this.pregReadSet 249 pregSet.map(cfg => backendParam.getRfWriteSize(cfg)).sum 250 } 251 252 def hasIQWakeUp: Boolean = numWakeupFromIQ > 0 && numRegSrc > 0 253 254 def needWakeupFromIntWBPort = backendParam.allExuParams.filter(x => !wakeUpInExuSources.map(_.name).contains(x.name)).groupBy(x => x.getIntWBPort.getOrElse(IntWB(port = -1)).port).filter(_._1 != -1) 255 256 def needWakeupFromVfWBPort = backendParam.allExuParams.groupBy(x => x.getVfWBPort.getOrElse(VfWB(port = -1)).port).filter(_._1 != -1) 257 258 def getFuCfgs: Seq[FuConfig] = exuBlockParams.flatMap(_.fuConfigs).distinct 259 260 def deqFuCfgs: Seq[Seq[FuConfig]] = exuBlockParams.map(_.fuConfigs) 261 262 def deqFuInterSect: Seq[FuConfig] = if (numDeq == 2) deqFuCfgs(0).intersect(deqFuCfgs(1)) else Seq() 263 264 def deqFuSame: Boolean = (numDeq == 2) && deqFuInterSect.length == deqFuCfgs(0).length && deqFuCfgs(0).length == deqFuCfgs(1).length 265 266 def deqFuDiff: Boolean = (numDeq == 2) && deqFuInterSect.length == 0 267 268 def deqImmTypes: Seq[UInt] = getFuCfgs.flatMap(_.immType).distinct 269 270 // set load imm to 32-bit for fused_lui_load 271 def deqImmTypesMaxLen: Int = if (isLdAddrIQ) 32 else deqImmTypes.map(SelImm.getImmUnion(_)).maxBy(_.len).len 272 273 def needImm: Boolean = deqImmTypes.nonEmpty 274 275 // cfgs(exuIdx)(set of exu's wb) 276 277 /** 278 * Get [[PregWB]] of this IssueBlock 279 * @return set of [[PregWB]] of [[ExeUnit]] 280 */ 281 def getWbCfgs: Seq[Set[PregWB]] = { 282 exuBlockParams.map(exu => exu.wbPortConfigs.toSet) 283 } 284 285 def canAccept(fuType: UInt): Bool = { 286 Cat(getFuCfgs.map(_.fuType.U === fuType)).orR 287 } 288 289 def bindBackendParam(param: BackendParams): Unit = { 290 backendParam = param 291 } 292 293 def wakeUpSourceExuIdx: Seq[Int] = { 294 wakeUpInExuSources.map(x => backendParam.getExuIdx(x.name)) 295 } 296 297 def genExuInputDecoupledBundle(implicit p: Parameters): MixedVec[DecoupledIO[ExuInput]] = { 298 MixedVec(this.exuBlockParams.map(x => DecoupledIO(x.genExuInputBundle))) 299 } 300 301 def genExuOutputDecoupledBundle(implicit p: Parameters): MixedVec[DecoupledIO[ExuOutput]] = { 302 MixedVec(this.exuParams.map(x => DecoupledIO(x.genExuOutputBundle))) 303 } 304 305 def genExuOutputValidBundle(implicit p: Parameters): MixedVec[ValidIO[ExuOutput]] = { 306 MixedVec(this.exuParams.map(x => ValidIO(x.genExuOutputBundle))) 307 } 308 309 def genExuBypassValidBundle(implicit p: Parameters): MixedVec[ValidIO[ExuBypassBundle]] = { 310 MixedVec(this.exuParams.filterNot(_.fakeUnit).map(x => ValidIO(x.genExuBypassBundle))) 311 } 312 313 def genIssueDecoupledBundle(implicit p: Parameters): MixedVec[DecoupledIO[IssueQueueIssueBundle]] = { 314 MixedVec(exuBlockParams.filterNot(_.fakeUnit).map(x => DecoupledIO(new IssueQueueIssueBundle(this, x)))) 315 } 316 317 def genWBWakeUpSinkValidBundle: MixedVec[ValidIO[IssueQueueWBWakeUpBundle]] = { 318 val intBundle: Seq[ValidIO[IssueQueueWBWakeUpBundle]] = schdType match { 319 case IntScheduler() | MemScheduler() => needWakeupFromIntWBPort.map(x => ValidIO(new IssueQueueWBWakeUpBundle(x._2.map(_.exuIdx), backendParam))).toSeq 320 case _ => Seq() 321 } 322 val vfBundle = schdType match { 323 case VfScheduler() | MemScheduler() => needWakeupFromVfWBPort.map(x => ValidIO(new IssueQueueWBWakeUpBundle(x._2.map(_.exuIdx), backendParam))).toSeq 324 case _ => Seq() 325 } 326 MixedVec(intBundle ++ vfBundle) 327 } 328 329 def genIQWakeUpSourceValidBundle(implicit p: Parameters): MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = { 330 MixedVec(exuBlockParams.map(x => ValidIO(new IssueQueueIQWakeUpBundle(x.exuIdx, backendParam, x.copyWakeupOut, x.copyNum)))) 331 } 332 333 def genIQWakeUpSinkValidBundle(implicit p: Parameters): MixedVec[ValidIO[IssueQueueIQWakeUpBundle]] = { 334 MixedVec(this.wakeUpInExuSources.map(x => ValidIO(new IssueQueueIQWakeUpBundle(backendParam.getExuIdx(x.name), backendParam)))) 335 } 336 337 def genOGRespBundle(implicit p: Parameters) = { 338 implicit val issueBlockParams = this 339 MixedVec(exuBlockParams.map(_ => new OGRespBundle)) 340 } 341 342 def genWbFuBusyTableWriteBundle()(implicit p: Parameters) = { 343 implicit val issueBlockParams = this 344 MixedVec(exuBlockParams.map(x => new WbFuBusyTableWriteBundle(x))) 345 } 346 347 def genWbFuBusyTableReadBundle()(implicit p: Parameters) = { 348 implicit val issueBlockParams = this 349 MixedVec(exuBlockParams.map{ x => 350 new WbFuBusyTableReadBundle(x) 351 }) 352 } 353 354 def genWbConflictBundle()(implicit p: Parameters) = { 355 implicit val issueBlockParams = this 356 MixedVec(exuBlockParams.map { x => 357 new WbConflictBundle(x) 358 }) 359 } 360 361 def getIQName = { 362 "IssueQueue" ++ getFuCfgs.map(_.name).distinct.map(_.capitalize).reduce(_ ++ _) 363 } 364 365 def getEntryName = { 366 "Entries" ++ getFuCfgs.map(_.name).distinct.map(_.capitalize).reduce(_ ++ _) 367 } 368} 369