perf: add cpi and topdown rolling db (#2280)

Add some rolling db:

* cpi rolling db
* topdown rolling db
* ipc-fuType rolling db

Others:
Add WITH_ROLLINGDB into Makefile, then: make emu WITH_ROLLINGDB=1 to enable rollingdb.
Topdown rolling db will add many table into the database. This is something a little ugly.

To sovle this:
* run emu with --dump-select-db for wanted table, not --dump-db
* TODO: enhance the RollingDB with more complicate YAXISPT that contains all the topdown signals

Makefile

@@ -53,6 +53,11 @@ ifeq ($(WITH_CHISELDB),1)
 override SIM_ARGS += --with-chiseldb
 endif
 
+# run emu with chisel-db
+ifeq ($(WITH_ROLLINGDB),1)
+override SIM_ARGS += --with-rollingdb
+endif
+
 # dynamic switch CONSTANTIN
 ifeq ($(WITH_CONSTANTIN),0)
 $(info disable WITH_CONSTANTIN)

src/main/scala/top/ArgParser.scala

@@ -35,6 +35,8 @@ object ArgParser {
       |--fpga-platform
       |--enable-difftest
       |--enable-log
+      |--with-chiseldb
+      |--with-rollingdb
       |--disable-perf
       |--mfc
       |""".stripMargin
@@ -76,6 +78,10 @@ object ArgParser {
           nextOption(config.alter((site, here, up) => {
             case DebugOptionsKey => up(DebugOptionsKey).copy(EnableChiselDB = true)
           }), tail)
+        case "--with-rollingdb" :: tail =>
+          nextOption(config.alter((site, here, up) => {
+            case DebugOptionsKey => up(DebugOptionsKey).copy(EnableRollingDB = true)
+          }), tail)
         case "--with-constantin" :: tail =>
           nextOption(config.alter((site, here, up) => {
             case DebugOptionsKey => up(DebugOptionsKey).copy(EnableConstantin = true)

src/main/scala/xiangshan/backend/dispatch/Dispatch.scala

@@ -343,6 +343,11 @@ class Dispatch(implicit p: Parameters) extends XSModule with HasPerfEvents {
 
   TopDownCounters.values.foreach(ctr => XSPerfAccumulate(ctr.toString(), PopCount(stallReason.map(_ === ctr.id.U))))
 
+  val robTrueCommit = WireInit(0.U(64.W))
+  ExcitingUtils.addSink(robTrueCommit, "ROBTrueCommit_hart" + p(XSCoreParamsKey).HartId.toString, ExcitingUtils.Perf)
+  TopDownCounters.values.foreach(ctr => XSPerfRolling("td_"+ctr.toString(), PopCount(stallReason.map(_ === ctr.id.U)),
+                                                      robTrueCommit, 1000, clock, reset))
+
   XSPerfHistogram("slots_fire", PopCount(thisActualOut), true.B, 0, RenameWidth+1, 1)
   // Explaination: when out(0) not fire, PopCount(valid) is not meaningfull
   XSPerfHistogram("slots_valid_pure", PopCount(io.enqRob.req.map(_.valid)), thisActualOut(0), 0, RenameWidth+1, 1)

src/main/scala/xiangshan/backend/rob/Rob.scala

@@ -1080,11 +1080,13 @@ class RobImp(outer: Rob)(implicit p: Parameters) extends LazyModuleImp(outer)
   val commitDebugExu = deqPtrVec.map(_.value).map(debug_exuDebug(_))
   val commitDebugUop = deqPtrVec.map(_.value).map(debug_microOp(_))
   val commitDebugLsInfo = deqPtrVec.map(_.value).map(debug_lsInfo(_))
+  ExcitingUtils.addSource(ifCommitReg(trueCommitCnt), "ROBTrueCommit_hart" + p(XSCoreParamsKey).HartId.toString, ExcitingUtils.Perf)
   XSPerfAccumulate("clock_cycle", 1.U)
   QueuePerf(RobSize, PopCount((0 until RobSize).map(valid(_))), !allowEnqueue)
   XSPerfAccumulate("commitUop", ifCommit(commitCnt))
   XSPerfAccumulate("commitInstr", ifCommitReg(trueCommitCnt))
   XSPerfRolling("ipc", ifCommitReg(trueCommitCnt), 1000, clock, reset)
+  XSPerfRolling("cpi", perfCnt = 1.U/*Cycle*/, eventTrigger = ifCommitReg(trueCommitCnt), granularity = 1000, clock, reset)
   val commitIsMove = commitDebugUop.map(_.ctrl.isMove)
   XSPerfAccumulate("commitInstrMove", ifCommit(PopCount(io.commits.commitValid.zip(commitIsMove).map{ case (v, m) => v && m })))
   val commitMoveElim = commitDebugUop.map(_.debugInfo.eliminatedMove)
@@ -1127,6 +1129,7 @@ class RobImp(outer: Rob)(implicit p: Parameters) extends LazyModuleImp(outer)
   for (fuType <- FuType.functionNameMap.keys) {
     val fuName = FuType.functionNameMap(fuType)
     val commitIsFuType = io.commits.commitValid.zip(commitDebugUop).map(x => x._1 && x._2.ctrl.fuType === fuType.U )
+    XSPerfRolling(s"ipc_futype_${fuName}", ifCommit(PopCount(commitIsFuType)), 1000, clock, reset)
     XSPerfAccumulate(s"${fuName}_instr_cnt", ifCommit(PopCount(commitIsFuType)))
     XSPerfAccumulate(s"${fuName}_latency_dispatch", ifCommit(latencySum(commitIsFuType, dispatchLatency)))
     XSPerfAccumulate(s"${fuName}_latency_enq_rs", ifCommit(latencySum(commitIsFuType, enqRsLatency)))