misc: Add param to target messages per second, bug fixes

Bug was with sending multiple values from one src to a
dest. Fixed it to cap at number of rlTimeSlots in a
connection window.
Using the above concept, we can reach a target number
of messages per second.

Author: kunpai

configs/supernetwork/SRNoC.py

@@ -155,16 +155,26 @@ def create_base_parser():
         "--maximum-values", type=int, default=0, help="Maximum values"
     )
     parser.add_argument(
+        "--no-buffer",
+        action="store_true",
+        help="Use no buffer mode (default is buffered mode)",
+    )
+
+    # Mutually exclusive group for value rate config
+    group = parser.add_mutually_exclusive_group(required=False)
+    group.add_argument(
         "--values-per-port-per-window",
         type=int,
         default=1,
         help="values per port per window",
     )
-    parser.add_argument(
-        "--no-buffer",
-        action="store_true",
-        help="Use no buffer mode (default is buffered mode)",
+    group.add_argument(
+        "--target-mps",
+        type=float,
+        default=-1.0,
+        help="Target million packets per second",
     )
+
     return parser
 
 
@@ -269,6 +279,7 @@ def main():
             crosspoint_setup_time=NetworkDelays.CROSSPOINT_SETUP_TIME.value,
             hold_time=NetworkDelays.CROSSPOINT_HOLD_TIME.value,
             values_per_port_per_window=args.values_per_port_per_window,
+            target_mps=args.target_mps,
             clk_domain=SrcClockDomain(
                 clock=frequency,
                 voltage_domain=VoltageDomain(),

src/network/Layer.py

@@ -59,6 +59,9 @@ class Layer(ClockedObject):
     )
     hold_time = Param.Float(-1, "Hold time in picoseconds")
     values_per_port_per_window = Param.Int(1, "Values per port per window")
+    target_mps = Param.Float(
+        -1, "Target million packets per second; -1 means not provided"
+    )
 
     cxx_exports = [
         PyBindMethod("setRandomTrafficMode"),

src/network/layer.cc

@@ -66,6 +66,7 @@ Layer::Layer(const LayerParams& params) :
     valuesDelivered(0),
     currentTimeSlotIndex(0),
     valuesPerPortPerWindow(params.values_per_port_per_window),
+    targetMMPS(params.target_mps),
     isFinished(false),
     fileMode(false),
     shuffleEnabled(false),
@@ -187,6 +188,57 @@ Layer::computeTimingParameters()
     DPRINTF(Layer, "Connection window: %d ps\n",
         getConnectionWindow()
     );
+
+    if (targetMMPS >= 0) {
+        double values_this_window =
+            static_cast<double>(targetMMPS) * 1e6 *
+            (static_cast<double>(getConnectionWindow()) / 1e12);
+
+        DPRINTF(Layer,
+            "Values this window: %f\n",
+            values_this_window
+        );
+
+        // spread them evenly across ports, round *up*
+        valuesPerPortPerWindow =
+            std::ceil(values_this_window / static_cast<double>(size));
+
+        DPRINTF(Layer,
+            "Value per port per window: %lu\n",
+            valuesPerPortPerWindow
+        );
+
+        // safety: never let it exceed the hard structural cap
+        valuesPerPortPerWindow =
+            std::min<uint64_t>(valuesPerPortPerWindow,
+                            maxValuesPerWindow * size);
+        DPRINTF(Layer,
+            "Target MMPS: %f\n",
+            targetMMPS
+        );
+        DPRINTF(Layer,
+            "Values per port per window: %lu\n",
+            valuesPerPortPerWindow
+        );
+        if (valuesPerPortPerWindow == 0) {
+            fatal("Layer %s: Target MMPS (%f) is too low!\n",
+                name(), targetMMPS);
+        }
+        if (valuesPerPortPerWindow > (maxValuesPerWindow * size)) {
+            warn("Layer %s: Target MMPS (%f) is too high!\n",
+                name(), targetMMPS);
+            warn("Layer %s: Setting values per port per \
+                window to %lu\n",
+                name(),(maxValuesPerWindow * size));
+        }
+    }
+
+    if (valuesPerPortPerWindow > maxValues) {
+        fatal("Values per port per window (%lu) \
+            exceeds max values (%lu)\n",
+            name(), valuesPerPortPerWindow, maxValues);
+    }
+
 }
 
 // Calculate the time slot based on network component delays
@@ -305,6 +357,14 @@ Layer::processValues(
             );
             break;
         }
+        if (valuesPerPortPerWindow > rlTimeSlots) {
+            warn("Layer %s: values per port per window (%lu) "
+                "exceeds RL time slots (%lu)\n",
+                name(), valuesPerPortPerWindow, rlTimeSlots);
+            warn("Layer %s: setting values per port per window to %lu\n",
+                name(), rlTimeSlots);
+            valuesPerPortPerWindow = rlTimeSlots;
+        }
         // Check if we've already reached the maximum values
         if (valuesDelivered >= maxValues && !infinite_mode) {
             break;  // Exit the loop immediately if we've reached max values
@@ -449,7 +509,7 @@ Layer::processValues(
             uint64_t payload;
             used_payloads.reserve(valuesPerPortPerWindow);
             while (used_payloads.size() < valuesPerPortPerWindow) {
-                uint64_t p = scheduler.generateRandomPayload(rlTimeSlots - 1);
+                uint64_t p = scheduler.generateRandomPayload(rlTimeSlots);
                 if (std::find(used_payloads.begin(),
                             used_payloads.end(),
                             p)
@@ -458,6 +518,18 @@ Layer::processValues(
                 }
             }
 
+            // Sort the payloads in ascending order
+            std::sort(used_payloads.begin(), used_payloads.end());
+
+            // print the payloads
+            DPRINTF(Layer,
+                "BufferedPort %lu: payloads for %lu: ",
+                src_addr, value_dest
+            );
+            for (auto p : used_payloads) {
+                DPRINTF(Layer, "%lu ", p);
+            }
+
             for (auto p : used_payloads) {
                 // Calculate precise delivery time
                 // within the connection window

src/network/layer.hh

@@ -74,7 +74,8 @@ private:
     uint64_t currentTimeSlotIndex;  // Current index for the time slot
     int maxValues;  // Maximum number of values, -1 means no limit
     int valuesDelivered; // Number of value deliveries
-    uint32_t valuesPerPortPerWindow; // Values per port per window
+    int valuesPerPortPerWindow; // Values per port per window
+    double targetMMPS; // Target million messages per second of the network
     int size; // Size of the network
     bool isFinished;  // Flag to indicate if the layer has finished
     bool fileMode;  // Flag to indicate if a file is used for scheduling