xref: /XiangShan/src/main/scala/xiangshan/backend/issue/EnqEntry.scala (revision bb2f3f51dd67f6e16e0cc1ffe43368c9fc7e4aef) 
1package xiangshan.backend.issue
2
3import org.chipsalliance.cde.config.Parameters
4import chisel3._
5import chisel3.util._
6import utility.{HasCircularQueuePtrHelper, GatedValidRegNext}
7import utils.{MathUtils, OptionWrapper}
8import xiangshan._
9import xiangshan.backend.Bundles._
10import xiangshan.backend.fu.FuType
11import xiangshan.backend.datapath.DataSource
12import xiangshan.backend.rob.RobPtr
13import xiangshan.backend.issue.EntryBundles._
14import xiangshan.mem.{MemWaitUpdateReq, SqPtr, LqPtr}
15
16
17class EnqEntryIO(implicit p: Parameters, params: IssueBlockParams) extends XSBundle {
18  //input
19  val commonIn            = new CommonInBundle
20  val enqDelayIn1         = new EnqDelayInBundle
21  val enqDelayIn2         = new EnqDelayInBundle
22
23  //output
24  val commonOut           = new CommonOutBundle
25
26  def wakeup              = commonIn.wakeUpFromWB ++ commonIn.wakeUpFromIQ
27}
28
29class EnqEntry(isComp: Boolean)(implicit p: Parameters, params: IssueBlockParams) extends XSModule {
30  val io = IO(new EnqEntryIO)
31
32  val common              = Wire(new CommonWireBundle)
33  val entryUpdate         = Wire(new EntryBundle)
34  val entryRegNext        = Wire(new EntryBundle)
35  val enqDelayValidRegNext= Wire(Bool())
36  val hasWakeupIQ         = OptionWrapper(params.hasIQWakeUp, Wire(new CommonIQWakeupBundle))
37
38  val currentStatus               = Wire(new Status())
39  val enqDelaySrcState            = Wire(Vec(params.numRegSrc, SrcState()))
40  val enqDelayDataSources         = Wire(Vec(params.numRegSrc, DataSource()))
41  val enqDelaySrcWakeUpL1ExuOH    = OptionWrapper(params.hasIQWakeUp, Wire(Vec(params.numRegSrc, ExuVec())))
42  val enqDelaySrcLoadDependency   = Wire(Vec(params.numRegSrc, Vec(LoadPipelineWidth, UInt(LoadDependencyWidth.W))))
43
44  //Reg
45  val validReg = GatedValidRegNext(common.validRegNext, false.B)
46  val entryReg = RegEnable(entryRegNext, validReg || common.validRegNext)
47  val enqDelayValidReg = GatedValidRegNext(enqDelayValidRegNext, false.B)
48
49  //Wire
50  CommonWireConnect(common, hasWakeupIQ, validReg, currentStatus, io.commonIn, true)
51
52  when(io.commonIn.enq.valid) {
53    assert(common.enqReady, "Entry is not ready when enq is valid\n")
54  }
55
56  when(io.commonIn.enq.valid && common.enqReady) {
57    entryRegNext := io.commonIn.enq.bits
58  }.otherwise {
59    entryRegNext := entryUpdate
60  }
61
62  when(io.commonIn.enq.valid && common.enqReady) {
63    enqDelayValidRegNext := true.B
64  }.otherwise {
65    enqDelayValidRegNext := false.B
66  }
67
68  if (params.hasIQWakeUp) {
69    ShiftLoadDependency(hasWakeupIQ.get)
70    CommonIQWakeupConnect(common, hasWakeupIQ.get, validReg, currentStatus, io.commonIn, true)
71  }
72
73  // enq delay wakeup
74  val enqDelayOut1         = Wire(new EnqDelayOutBundle)
75  val enqDelayOut2         = Wire(new EnqDelayOutBundle)
76  EnqDelayWakeupConnect(io.enqDelayIn1, enqDelayOut1, entryReg.status, delay = 1)
77  EnqDelayWakeupConnect(io.enqDelayIn2, enqDelayOut2, entryReg.status, delay = 2)
78
79  for (i <- 0 until params.numRegSrc) {
80    val enqDelay1WakeUpValid = enqDelayOut1.srcWakeUpByIQVec(i).asUInt.orR
81    val enqDelay1WakeUpOH    = enqDelayOut1.srcWakeUpByIQVec(i)
82    val enqDelay2WakeUpOH    = enqDelayOut2.srcWakeUpByIQVec(i)
83    val enqDelay1IsWakeupByMemIQ = enqDelay1WakeUpOH.zip(io.commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _)
84    val enqDelay2IsWakeupByMemIQ = enqDelay2WakeUpOH.zip(io.commonIn.wakeUpFromIQ).filter(_._2.bits.params.isMemExeUnit).map(_._1).fold(false.B)(_ || _)
85    val enqDelay2IsWakeupByVfIQ  = enqDelay2WakeUpOH.zip(io.commonIn.wakeUpFromIQ).filter(_._2.bits.params.isVfExeUnit).map(_._1).fold(false.B)(_ || _)
86
87    if (params.inVfSchd && params.readVfRf && params.hasIQWakeUp) {
88      enqDelayDataSources(i).value            := MuxCase(entryReg.status.srcStatus(i).dataSources.value, Seq(
89                                                    (enqDelayOut1.srcWakeUpByIQ(i).asBool && !enqDelay1IsWakeupByMemIQ)  -> DataSource.bypass,
90                                                    (enqDelayOut1.srcWakeUpByIQ(i).asBool && enqDelay1IsWakeupByMemIQ)   -> DataSource.bypass2,
91                                                    (enqDelayOut2.srcWakeUpByIQ(i).asBool && !enqDelay2IsWakeupByMemIQ)  -> DataSource.bypass2,
92                                                 ))
93      enqDelaySrcWakeUpL1ExuOH.get(i)         := Mux(enqDelay1WakeUpValid,
94                                                      Mux1H(enqDelay1WakeUpOH, params.wakeUpSourceExuIdx.map(x => VecInit(MathUtils.IntToOH(x).U(backendParams.numExu.W).asBools)).toSeq),
95                                                      Mux1H(enqDelay2WakeUpOH, params.wakeUpSourceExuIdx.map(x => VecInit(MathUtils.IntToOH(x).U(backendParams.numExu.W).asBools)).toSeq))
96    }
97    else if (params.inMemSchd && params.readVfRf && params.hasIQWakeUp) {
98      enqDelayDataSources(i).value            := MuxCase(entryReg.status.srcStatus(i).dataSources.value, Seq(
99                                                    enqDelayOut1.srcWakeUpByIQ(i).asBool                                 -> DataSource.bypass,
100                                                    (enqDelayOut2.srcWakeUpByIQ(i).asBool && enqDelay2IsWakeupByVfIQ)    -> DataSource.bypass2,
101                                                 ))
102      enqDelaySrcWakeUpL1ExuOH.get(i)         := Mux(enqDelay1WakeUpValid,
103                                                      Mux1H(enqDelay1WakeUpOH, params.wakeUpSourceExuIdx.map(x => VecInit(MathUtils.IntToOH(x).U(backendParams.numExu.W).asBools)).toSeq),
104                                                      Mux1H(enqDelay2WakeUpOH,  params.wakeUpSourceExuIdx.map(x => VecInit(MathUtils.IntToOH(x).U(backendParams.numExu.W).asBools)).toSeq))
105    }
106    else {
107      enqDelayDataSources(i).value            := Mux(enqDelayOut1.srcWakeUpByIQ(i).asBool, DataSource.bypass, entryReg.status.srcStatus(i).dataSources.value)
108      if (params.hasIQWakeUp) {
109        enqDelaySrcWakeUpL1ExuOH.get(i)       := Mux1H(enqDelay1WakeUpOH, params.wakeUpSourceExuIdx.map(x => VecInit(MathUtils.IntToOH(x).U(backendParams.numExu.W).asBools)).toSeq)
110      }
111    }
112
113    enqDelaySrcState(i)                     := (!enqDelayOut1.srcCancelByLoad(i) & entryReg.status.srcStatus(i).srcState) | enqDelayOut1.srcWakeUpByWB(i) | enqDelayOut1.srcWakeUpByIQ(i)
114    if (params.hasIQWakeUp) {
115      enqDelaySrcLoadDependency(i)          := Mux(enqDelay1WakeUpValid, Mux1H(enqDelay1WakeUpOH, enqDelayOut1.shiftedWakeupLoadDependencyByIQVec), entryReg.status.srcStatus(i).srcLoadDependency)
116    } else {
117      enqDelaySrcLoadDependency(i)          := entryReg.status.srcStatus(i).srcLoadDependency
118    }
119  }
120
121  // current status
122  currentStatus                             := entryReg.status
123  when (enqDelayValidReg) {
124    currentStatus.srcStatus.zipWithIndex.foreach { case (srcStatus, srcIdx) =>
125      srcStatus.srcState                    := enqDelaySrcState(srcIdx)
126      srcStatus.dataSources                 := enqDelayDataSources(srcIdx)
127      srcStatus.srcLoadDependency           := enqDelaySrcLoadDependency(srcIdx)
128    }
129  }
130
131  if (params.hasIQWakeUp) {
132    currentStatus.srcStatus.map(_.srcWakeUpL1ExuOH.get).zip(entryReg.status.srcStatus.map(_.srcWakeUpL1ExuOH.get)).zip(enqDelaySrcWakeUpL1ExuOH.get).foreach {
133      case ((currExuOH, regExuOH), enqDelayExuOH) =>
134        currExuOH := 0.U.asTypeOf(currExuOH)
135        params.wakeUpSourceExuIdx.foreach(x => currExuOH(x) := Mux(enqDelayValidReg, enqDelayExuOH(x), regExuOH(x)))
136    }
137  }
138
139  EntryRegCommonConnect(common, hasWakeupIQ, validReg, entryUpdate, entryReg, currentStatus, io.commonIn, true)
140
141  //output
142  CommonOutConnect(io.commonOut, common, hasWakeupIQ, validReg, entryUpdate, entryReg, currentStatus, io.commonIn, true, isComp)
143}
144
145class EnqEntryVecMem(isComp: Boolean)(implicit p: Parameters, params: IssueBlockParams) extends EnqEntry(isComp)
146  with HasCircularQueuePtrHelper {
147
148  require(params.isVecMemIQ, "EnqEntryVecMem can only be instance of VecMem IQ")
149
150  EntryVecMemConnect(io.commonIn, common, validReg, entryReg, entryRegNext, entryUpdate)
151}
152
153object EnqEntry {
154  def apply(isComp: Boolean)(implicit p: Parameters, iqParams: IssueBlockParams): EnqEntry = {
155    iqParams.schdType match {
156      case IntScheduler() => new EnqEntry(isComp)
157      case FpScheduler()  => new EnqEntry(isComp)
158      case MemScheduler() =>
159        if (iqParams.isVecMemIQ) new EnqEntryVecMem(isComp)
160        else new EnqEntry(isComp)
161      case VfScheduler() => new EnqEntry(isComp)
162      case _ => null
163    }
164  }
165}