sim: improve ux

Author: depctg

pifo-hardware/hw/spinal/rio/sim/PifoMeshSim.scala

@@ -24,31 +24,27 @@ object PifoMeshSim extends App {
 
     controller.start
 
-    val flow0 = 0xE
-    val flow1 = 0xF
-
-    val vPifo_A = 0xA
-    val vPifo_B = 0xB
-    val vPifo_C = 0xC
-
-    val engine1 = 1
-    val engine2 = 2
+    import RioPredefinedPifos._
 
     val tree1 = TreeController(
       controller,
-      pifos = Seq((engine1, vPifo_A), (engine2, vPifo_B), (engine2, vPifo_C))
+      pifos = Seq((1, rPifo(0)), (2, rPifo(1)), (2, rPifo(2)))
     )
 
-    val configThread = tree1.async_config { tc => {
-      tc.addFlow(flow0, Seq(vPifo_A, vPifo_B))
-      tc.addFlow(flow1, Seq(vPifo_A, vPifo_C))
 
-      tc.setBrainSP(vPifo_A)
-      tc.setBrainState(vPifo_A, flow0, 10)  // prio flow0 -> 10
-      tc.setBrainState(vPifo_A, flow1, 20)  // prio flow1 -> 20
-      tc.setBrainFIFO(vPifo_B)
-      tc.setBrainFIFO(vPifo_C)
-    }}
+    // use controller.transaction if you want transactional configuration
+    val configThread = controller.config { cf =>
+      cf.tree(tree1)
+       .addFlow(rFlow(0), Seq(rPifo(0), rPifo(1)))
+       .addFlow(rFlow(1), Seq(rPifo(0), rPifo(2)))
+
+       .brainSP(rPifo(0))
+       .brainState(rPifo(0), rFlow(0), 10)  // prio flow0 -> 10
+       .brainState(rPifo(0), rFlow(1), 20)  // prio flow1 -> 20
+
+       .brainFIFO(rPifo(1))
+       .brainFIFO(rPifo(2))
+    }
 
     // join here to ensure configuration completes before proceeding
     // but you could let it run in parallel with other testbench activity!
@@ -57,17 +53,16 @@ object PifoMeshSim extends App {
     println("=== PifoMesh Simulation: Multi-Engine Test ===")
     dut.clockDomain.waitRisingEdge(4)
 
-    println(s"Enqueueing packets to Engine $engine1")
     for (i <- 0 until 3) {
-      controller.enque(flow0)
+      controller.enque(rFlow(0))
       dut.clockDomain.waitRisingEdge(1)
-      controller.enque(flow1)
+      controller.enque(rFlow(1))
       dut.clockDomain.waitRisingEdge(1)
     }
 
     dut.clockDomain.waitRisingEdge(6)
 
-    println(s"Requesting dequeue from Engine $engine1 (root vPifo=$vPifo_A):")
+    println(s"Requesting dequeue (root vPifo=${rPifo(0)}):")
     for (_ <- 0 until 8) {
       tree1.deque
     }

pifo-hardware/hw/spinal/rio/sim/Utils.scala

@@ -12,24 +12,18 @@ object SimUtils {
       .withFstWave
 }
 
+// TODO(zhiyuang): check the pifos and flow ids are valid
+object RioPredefinedPifos {
+  // pifos are 0xA to 0xF
+  val rPifo : Seq[Int] = 10 until 16
+  // flows are 1 to 9
+  val rFlow : Seq[Int] = 1 until 10
+}
+
 case class PifoMeshSimController(
   config: EngineConfig,
   dut: PifoMesh
 ) {
-  // high-level functions
-  def setBrainFIFO(engineId: Int, vPifoId: Int) = {
-    sendControl(ControlCommand.UpdateBrainEngine, engineId, 3, vPifoId = vPifoId)  // FIFO
-  }
-  def setBrainSP(engineId: Int, vPifoId: Int) = {
-    sendControl(ControlCommand.UpdateBrainEngine, engineId, 2, vPifoId = vPifoId)  // SP
-  }
-  def setBrainWFQ(engineId: Int, vPifoId: Int) = {
-    sendControl(ControlCommand.UpdateBrainEngine, engineId, 1, vPifoId = vPifoId)  // WFQ
-  }
-
-  def setBrainState(engineId: Int, vPifoId: Int, flowId: Int, state: Int) = {
-    sendControl(ControlCommand.UpdateBrainFlowState, engineId, state, vPifoId = vPifoId, flowId = mkFlowId(engineId, flowId))
-  }
 
   // compound functions
   def enque(vPifoId: Int) = {
@@ -102,6 +96,100 @@ case class PifoMeshSimController(
     }
   }
 
+  // high-level configuration interface
+  case class Configer(transactional: Boolean = false) {
+    // high-level functions
+    def setBrainFIFO(engineId: Int, vPifoId: Int) = {
+      sendControl(ControlCommand.UpdateBrainEngine, engineId, 3, vPifoId = vPifoId)  // FIFO
+    }
+    def setBrainSP(engineId: Int, vPifoId: Int) = {
+      sendControl(ControlCommand.UpdateBrainEngine, engineId, 2, vPifoId = vPifoId)  // SP
+    }
+    def setBrainWFQ(engineId: Int, vPifoId: Int) = {
+      sendControl(ControlCommand.UpdateBrainEngine, engineId, 1, vPifoId = vPifoId)  // WFQ
+    }
+
+    def setBrainState(engineId: Int, vPifoId: Int, flowId: Int, state: Int) = {
+      sendControl(ControlCommand.UpdateBrainFlowState, engineId, state, vPifoId = vPifoId, flowId = mkFlowId(engineId, flowId))
+    }
+
+    case class TreeConfiger(tree : TreeController) {
+      def addPifo(engineId : Int, pifoId : Int) : TreeConfiger = {
+        assert(engineId <= config.numEngines, s"Invalid engineId: $engineId")
+        assert(!tree.pifoMap.contains(pifoId), s"pifoId $pifoId already exists in the tree")
+        tree.pifoMap(pifoId) = engineId
+        this
+      }
+
+      def addFlow(flowId : Int, vPifos : Seq[Int]) : TreeConfiger = {
+        for (i <- 0 until vPifos.length) {
+          val engine = tree.pifoMap(vPifos(i))
+          val vPifo = vPifos(i)
+
+          sendControl(ControlCommand.UpdateMapperPre, engine, vPifo, vPifoId = flowId)
+          val nextvPifo = if (i + 1 < vPifos.length) vPifos(i + 1) else flowId
+          val nextEngine = if (i + 1 < vPifos.length) tree.pifoMap(nextvPifo) else 0
+          sendControl(
+            ControlCommand.UpdateMapperPost,
+            engine, mkFlowId(nextEngine, nextvPifo),
+            flowId = mkFlowId(engine, flowId)
+          )
+        }
+        this
+      }
+      // apply the non-exist rewrite at the root pifo
+      def rootNonExistRewrite(newEngineId : Int, newPifoId : Int) : TreeConfiger = {
+        sendControl(
+          ControlCommand.UpdateMapperPost,
+          tree.rootEngine,
+          mkFlowId(newEngineId, newPifoId),
+          flowId = mkFlowId(tree.rootEngine, tree.rootPifo)
+        )
+        this
+      }
+
+      // brain operations
+      // TODO(zhiyuang): limitations on transactional updates
+      def brainFIFO(vPifoId: Int) : TreeConfiger = {
+        // assert(!transactional, "setBrainFIFO is not supported in transactional mode")
+        val engineId = tree.pifoMap(vPifoId)
+        setBrainFIFO(engineId, vPifoId)
+        this
+      }
+      def brainSP(vPifoId: Int) : TreeConfiger = {
+        val engineId = tree.pifoMap(vPifoId)
+        setBrainSP(engineId, vPifoId)
+        this
+      }
+      def brainWFQ(vPifoId: Int) : TreeConfiger = {
+        val engineId = tree.pifoMap(vPifoId)
+        setBrainWFQ(engineId, vPifoId)
+        this
+      }
+      def brainState(vPifoId: Int, flowId: Int, state: Int) : TreeConfiger = {
+        val engineId = tree.pifoMap(vPifoId)
+        setBrainState(engineId, vPifoId, flowId, state)
+        this
+      }
+    }
+
+    def tree(tree : TreeController) : TreeConfiger = TreeConfiger(tree)
+  }
+
+  // Transactional configuration process.
+  // TODO(zhiyuang): make this async and transactional
+  def transaction(F : Configer => Unit) : SimThread = {
+    assert(false,  "Transactional configuration is not yet implemented")
+    val configer = Configer(transactional = true)
+    fork { F(configer) }
+  }
+
+  def config(F : Configer => Unit) : SimThread = {
+    val configer = Configer(transactional = false)
+    fork { F(configer) }
+  }
+
+  ///////////////////////////////////
   // Initialize all inputs
   for (i <- 0 until config.numEngines) {
     dut.io.insert(i).valid #= false
@@ -142,75 +230,6 @@ case class TreeController(
     meshController.requestDequeue(rootEngine, rootPifo)
   }
 
-  // configuration interface
-  case class TreeConfiger(transactional : Boolean = false) {
-    def addPifo(engineId : Int, pifoId : Int) = {
-      assert(engineId <= meshController.config.numEngines, s"Invalid engineId: $engineId")
-      assert(!pifoMap.contains(pifoId), s"pifoId $pifoId already exists in the tree")
-      pifoMap(pifoId) = engineId
-    }
-
-    def addFlow(flowId : Int, vPifos : Seq[Int]) = {
-      for (i <- 0 until vPifos.length) {
-        val engine = pifoMap(vPifos(i))
-        val vPifo = vPifos(i)
-
-        meshController.sendControl(ControlCommand.UpdateMapperPre, engine, vPifo, vPifoId = flowId)
-        val nextvPifo = if (i + 1 < vPifos.length) vPifos(i + 1) else flowId
-        val nextEngine = if (i + 1 < vPifos.length) pifoMap(nextvPifo) else 0
-        meshController.sendControl(
-          ControlCommand.UpdateMapperPost,
-          engine, meshController.mkFlowId(nextEngine, nextvPifo),
-          flowId = meshController.mkFlowId(engine, flowId)
-        )
-      }
-    }
-    // apply the non-exist rewrite at the root pifo
-    def rootNonExistRewrite(newEngineId : Int, newPifoId : Int) = {
-      meshController.sendControl(
-        ControlCommand.UpdateMapperPost,
-        rootEngine,
-        meshController.mkFlowId(newEngineId, newPifoId),
-        flowId = meshController.mkFlowId(rootEngine, rootPifo)
-      )
-    }
-
-    // brain operations
-    // TODO(zhiyuang): limitations on transactional updates
-    def setBrainFIFO(vPifoId: Int) = {
-      // assert(!transactional, "setBrainFIFO is not supported in transactional mode")
-      val engineId = pifoMap(vPifoId)
-      meshController.setBrainFIFO(engineId, vPifoId)
-    }
-    def setBrainSP(vPifoId: Int) = {
-      val engineId = pifoMap(vPifoId)
-      meshController.setBrainSP(engineId, vPifoId)
-    }
-    def setBrainWFQ(vPifoId: Int) = {
-      val engineId = pifoMap(vPifoId)
-      meshController.setBrainWFQ(engineId, vPifoId)
-    }
-    def setBrainState(vPifoId: Int, flowId: Int, state: Int) = {
-      val engineId = pifoMap(vPifoId)
-      meshController.setBrainState(engineId, vPifoId, flowId, state)
-    }
-  }
-
-  // Transactional configuration process.
-  // TODO(zhiyuang): make this async and transactional
-  def transaction(F : TreeConfiger => Unit) : SimThread = {
-    val configer = TreeConfiger(true)
-    fork { F(configer) }
-  }
-
-  def async_config(F : TreeConfiger => Unit) : SimThread = {
-    val configer = TreeConfiger(false)
-    fork { F(configer) }
-  }
-  def config(F : TreeConfiger => Unit) : Unit = {
-    async_config(F).join()
-  }
-
   // init code
   pifos.foreach { case (engineId, pifoId) =>
     // insert the pifo into the map