xref: /XiangShan/src/main/scala/xiangshan/backend/datapath/Og2ForVector.scala (revision 42b6cdf9744fdb03eb7e5a7e7505d0c89eb40abd) 
1package xiangshan.backend.datapath
2
3import org.chipsalliance.cde.config.Parameters
4import chisel3._
5import chisel3.util._
6import utility._
7import xiangshan._
8import xiangshan.backend.BackendParams
9import xiangshan.backend.Bundles._
10import xiangshan.backend.issue.EntryBundles.{EntryDeqRespBundle, RespType}
11import xiangshan.backend.issue.{MemScheduler, VfScheduler}
12import xiangshan.mem.{SqPtr, LqPtr}
13
14
15class Og2ForVector(params: BackendParams)(implicit p: Parameters) extends XSModule {
16  val io = IO(new Og2ForVectorIO(params))
17
18  private val fromOg1             = io.fromOg1VfArith ++ io.fromOg1VecMem
19  private val toExu               = io.toVfArithExu ++ io.toVecMemExu
20  private val toIQOg2Resp         = io.toVfIQOg2Resp ++ io.toMemIQOg2Resp
21
22  private val s1_validVec2        = fromOg1.map(_.map(_.valid))
23  private val s1_dataVec2         = fromOg1.map(_.map(_.bits))
24  private val s1_readyVec2        = fromOg1.map(_.map(_.ready))
25  private val toExuFire           = toExu.map(_.map(_.fire))
26  private val toExuReady          = toExu.map(_.map(_.ready))
27  private val og2IQNum: Int       = fromOg1.size
28  private val og2IQPerExuNum      = fromOg1.map(_.size).toSeq
29
30  val s2_toExuValid               = Reg(MixedVec(
31    s1_validVec2.map(x => MixedVec(x.map(_.cloneType).toSeq)).toSeq
32  ))
33  val s2_toExuData                = Reg(MixedVec(
34    s1_dataVec2.map(x => MixedVec(x.map(_.cloneType).toSeq)).toSeq
35  ))
36
37  for(i <- 0 until og2IQNum) {
38    for (j <- 0 until og2IQPerExuNum(i)) {
39      val s2_flush = s1_dataVec2(i)(j).robIdx.needFlush(Seq(io.flush, RegNextWithEnable(io.flush)))
40      val s1_ldCancel = LoadShouldCancel(s1_dataVec2(i)(j).loadDependency, io.ldCancel)
41      when(s1_validVec2(i)(j) && s1_readyVec2(i)(j) && !s2_flush && !s1_ldCancel) {
42        s2_toExuValid(i)(j) := true.B
43        s2_toExuData(i)(j) := s1_dataVec2(i)(j)
44        s2_toExuData(i)(j).loadDependency.foreach(_ := s1_dataVec2(i)(j).loadDependency.get.map(_ << 1))
45      }.otherwise {
46        s2_toExuValid(i)(j) := false.B
47      }
48      s1_readyVec2(i)(j) := true.B
49      toExu(i)(j).valid := s2_toExuValid(i)(j)
50      toExu(i)(j).bits := s2_toExuData(i)(j)
51    }
52  }
53  toIQOg2Resp.zipWithIndex.foreach {
54    case (toIQ, iqId) =>
55      toIQ.zipWithIndex.foreach {
56        case (og2Resp, exuId) =>
57          val og2Failed = s2_toExuValid(iqId)(exuId) && !toExuReady(iqId)(exuId)
58          og2Resp.valid := s2_toExuValid(iqId)(exuId)
59          og2Resp.bits.robIdx := s2_toExuData(iqId)(exuId).robIdx
60          og2Resp.bits.uopIdx.foreach(_ := s2_toExuData(iqId)(exuId).vpu.get.vuopIdx)
61          og2Resp.bits.resp := Mux(og2Failed, RespType.block,
62            if (og2Resp.bits.params match { case x => x.isVecMemIQ })
63              RespType.uncertain
64            else
65              RespType.success
66          )
67          og2Resp.bits.fuType := s2_toExuData(iqId)(exuId).fuType
68          og2Resp.bits.sqIdx.foreach(_ := 0.U.asTypeOf(new SqPtr))
69          og2Resp.bits.lqIdx.foreach(_ := 0.U.asTypeOf(new LqPtr))
70      }
71  }
72  io.toBypassNetworkImmInfo := io.fromOg1ImmInfo.zip(s1_validVec2.flatten).map{
73    case (imm, valid) => RegEnable(imm, valid)
74  }
75}
76
77class Og2ForVectorIO(params: BackendParams)(implicit p: Parameters) extends XSBundle {
78  private val vfSchdParams = params.schdParams(VfScheduler())
79  private val memSchdParams = params.schdParams(MemScheduler())
80
81  val flush: ValidIO[Redirect]                                    = Flipped(ValidIO(new Redirect))
82  val ldCancel                                                    = Vec(backendParams.LduCnt + backendParams.HyuCnt, Flipped(new LoadCancelIO))
83
84  val fromOg1VfArith: MixedVec[MixedVec[DecoupledIO[ExuInput]]]   = Flipped(vfSchdParams.genExuInputBundle)
85  val fromOg1VecMem: MixedVec[MixedVec[DecoupledIO[ExuInput]]]    = Flipped(MixedVec(memSchdParams.issueBlockParams.filter(_.needOg2Resp).map(_.genExuInputDecoupledBundle)))
86  val fromOg1ImmInfo: Vec[ImmInfo]                                = Input(Vec(params.allIssueParams.filter(_.needOg2Resp).flatMap(_.exuBlockParams).size, new ImmInfo))
87
88  val toVfArithExu                                                = MixedVec(vfSchdParams.genExuInputBundle)
89  val toVecMemExu                                                 = MixedVec(memSchdParams.issueBlockParams.filter(_.needOg2Resp).map(_.genExuInputDecoupledBundle))
90  val toVfIQOg2Resp                                               = MixedVec(vfSchdParams.issueBlockParams.map(_.genOG2RespBundle))
91  val toMemIQOg2Resp                                              = MixedVec(memSchdParams.issueBlockParams.filter(_.needOg2Resp).map(_.genOG2RespBundle))
92  val toBypassNetworkImmInfo: Vec[ImmInfo]                        = Output(Vec(params.allIssueParams.filter(_.needOg2Resp).flatMap(_.exuBlockParams).size, new ImmInfo))
93}