doc: Collector IO

Author: hansungk

docs/issue.md

@@ -378,6 +378,30 @@ Operand collector consists of the following components:
     The (2) condition may not always hold when e.g. instruction mix is skewed
     and a single FU-type collector bank runs out of space.
 
+TODO: elaborate why a simple duplicate-bank regfile design requires collector
+logic.
+
+### IO
+
+The collector provides latency-insensitive interface for operand read/writes,
+so that the RS can make issue-scheduling decisions in a timing-decoupled way.
+
+See [src/main/scala/radiance/muon/Collector.scala] for the implementation.
+
+* `readReq`: Requests the collector to initiate an operand read and expose it
+to the `readData` port.
+* `readResp`: Indicates the requested operand will be available at the
+collector bank port (`readData`) *at the next cycle*.  RS uses this to
+arbitrate among eligible, all-collected instructions and expose it to the issue
+port at the next cycle, lining up with the collector data.
+* `writeReq`/`writeResp`: Same as `readReq`/`readResp` but for writes.
+* `writeReq`/`writeResp`: Same as `readReq`/`readResp` but for writes.  Normally
+the response has a 1-cycle latency because writes don't cause bank conflicts.
+* `readData`: Port that serves the operand data to EX.  Its member `req` tells
+to the collector which bank entry to be read, and `resp` exposes the full
+register vector-data stored at that entry to the port. `resp` is
+combinational-read.
+
 ### Collector banking strategies
 
 #### Source-register-banked collectors

src/main/scala/radiance/muon/ReservationStation.scala

@@ -67,9 +67,10 @@ class ReservationStation(implicit p: Parameters) extends CoreModule()(p) {
     }
   }
   def collFiredTable(row: Int): Vec[Bool] = collFiredTable(row.U)
-  // where the operand lives in the collector banks
+  // where the operand lives in the collector banks.  RS uses this to allocate a
+  // spot in the collector & feed the correct data to EX upon issue.
   val collPtrTable   = Mem(numEntries, Vec(Isa.maxNumRegs, UInt(collEntryWidth.W)))
-  val collAllReadyTable = Wire(Vec(numEntries, Bool()))
+  val collNeedAllReadyTable = Wire(Vec(numEntries, Bool()))
   // mostly for debugging
   val eligibleTable = WireDefault(VecInit.fill(numEntries)(false.B))
   dontTouch(eligibleTable)
@@ -128,10 +129,10 @@ class ReservationStation(implicit p: Parameters) extends CoreModule()(p) {
   // select a single entry for collection
   // TODO: @perf: currently a simple priority encoder; might introduce fairness
   // problem
-  val collBitvec = WireDefault(VecInit(needCollects.map(_._1)))
-  collAllReadyTable := VecInit(needCollects.map(_._3))
-  dontTouch(collBitvec)
-  dontTouch(collAllReadyTable)
+  val collNeedTable = WireDefault(VecInit(needCollects.map(_._1)))
+  collNeedAllReadyTable := VecInit(needCollects.map(_._3))
+  dontTouch(collNeedTable)
+  dontTouch(collNeedAllReadyTable)
 
   // don't allow early-firing collector requests for partial operands of an
   // instruction.  Partial collects may result in a deadlock with insufficient
@@ -148,9 +149,9 @@ class ReservationStation(implicit p: Parameters) extends CoreModule()(p) {
   // that, we need some kind of bookkeeping in the collector for the
   // partial-collect uops, which is what the collector banks are meant for,
   // which are expensive.
-  val allReadyExists = collAllReadyTable.reduce(_ || _)
-  val firstAllReadyRow = PriorityEncoder(collAllReadyTable)
-  val firstNeedRow = PriorityEncoder(collBitvec)
+  val allReadyExists = collNeedAllReadyTable.reduce(_ || _)
+  val firstAllReadyRow = PriorityEncoder(collNeedAllReadyTable)
+  val firstNeedRow = PriorityEncoder(collNeedTable)
   val collRow = Mux(!allowPartialCollect.B || allReadyExists,
     firstAllReadyRow, firstNeedRow)
   dontTouch(collRow)
@@ -428,6 +429,7 @@ class ReservationStation(implicit p: Parameters) extends CoreModule()(p) {
                cf"hasOp:${hasOpTable(i)(0)}${hasOpTable(i)(1)}${hasOpTable(i)(2)} | " +
                cf"opReady:${opReadyTable(i)(0)}${opReadyTable(i)(1)}${opReadyTable(i)(2)} | " +
                cf"busy:${busyTable(i)(0)}${busyTable(i)(1)}${busyTable(i)(2)} | " +
+               cf"collNeed:${collNeedAllReadyTable(i)} | " +
                cf"collFired:${collFiredTable(i)(0)}${collFiredTable(i)(1)}${collFiredTable(i)(2)} | " +
                cf"eligible:${eligibleTable(i)}" +
                cf"\n")