misc: Add latency tracking, no buffer mode

Latency tracking (in buffer + network delay)
No buffer mode; does not store in a buffer at all
Config script accepts a --no-buffer arg

Author: kunpai

configs/supernetwork/SRNoC.py

@@ -160,6 +160,11 @@ def create_base_parser():
         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)",
+    )
     return parser
 
 
@@ -326,6 +331,11 @@ def main():
         for layer in layers:
             layer.setRandomTrafficMode()
 
+    # Set the no buffer mode if specified.
+    if args.no_buffer:
+        for layer in layers:
+            layer.setNoBufferMode()
+
     exit_event = m5.simulate()
     print(f"Exiting @ tick {m5.curTick()} because {exit_event.getCause()}")
 

src/network/Layer.py

@@ -68,4 +68,5 @@ class Layer(ClockedObject):
         PyBindMethod("setBitComplementTrafficMode"),
         PyBindMethod("setNearestNeighborTrafficMode"),
         PyBindMethod("setShuffle"),
+        PyBindMethod("setNoBufferMode"),
     ]

src/network/buffered_port.cc

@@ -62,26 +62,35 @@ BufferedPort::getAddr()
 void
 BufferedPort::assignValue(uint64_t dest_addr)
 {
-    valueQueue.push(dest_addr);  // Queue the dest
+    valueQueue.emplace(ValueEntry{dest_addr, curTick()});
     DPRINTF(BufferedPort,
         "BufferedPort %d assigned value "
         "to destination %d\n",
         addr, dest_addr
     );
 }
 
+// Clear the queue of values
+void
+BufferedPort::clearQueue()
+{
+    while (!valueQueue.empty()) {
+        valueQueue.pop();
+    }
+}
+
 // Retrieves and removes the next value from the queue
 // Returns 0 if no values are available
-uint64_t
+ValueEntry
 BufferedPort::getNextValue()
 {
     if (!valueQueue.empty()) {
         // Get the next value and remove it from the queue
-        uint64_t nextValue = valueQueue.front();
+        ValueEntry nextValue = valueQueue.front();
         valueQueue.pop();
         return nextValue;
     }
-    return 0; // No value available
+    return ValueEntry{0, 0}; // No value available
 }
 
 // Checks if there are any values in the queue
@@ -118,9 +127,9 @@ uint64_t
 BufferedPort::peekNextValue() const
 {
     if (!valueQueue.empty()) {
-         return valueQueue.front();
+         return valueQueue.front().dest;
     }
-    return -1;  // No value available
+    return -1; // No value available
 }
 
 }  // namespace gem5

src/network/buffered_port.hh

@@ -36,7 +36,11 @@
 
 namespace gem5
 {
-
+struct ValueEntry
+{
+    uint64_t dest;
+    Tick     enqueueTick;
+};
 // The BufferedPort class represents a single node in the network
 // responsible for storing, sending, and receiving values.
 // It tracks its data, address, and maintains statistics for
@@ -48,7 +52,7 @@ class BufferedPort : public ClockedObject
         uint64_t addr;
 
         // Queue to hold values (destination addresses) assigned to the port
-        std::queue<uint64_t> valueQueue;
+        std::queue<ValueEntry> valueQueue;
 
         // Variables to store the most recent received data and source addr
         uint64_t lastReceivedData = 0;
@@ -67,14 +71,18 @@ class BufferedPort : public ClockedObject
         uint64_t getAddr();
 
         // Assigns a value to the queue with the given destination address
-        void assignValue(uint64_t dest_addr);
+        // The value is stored with the current tick as the enqueue time
+        void assignValue(uint64_t dest);
+
+        // Clears the queue of values
+        void clearQueue();
 
         // Receives data from another port
         // Stores the received value and source
         void receiveData(uint64_t received_data, uint64_t src_addr);
 
         // Retrieves and removes the next value from the queue
-        uint64_t getNextValue();
+        ValueEntry getNextValue();
 
         // Checks if the port has any values in its queue
         bool hasValues() const;

src/network/layer.cc

@@ -69,6 +69,7 @@ Layer::Layer(const LayerParams& params) :
     isFinished(false),
     fileMode(false),
     shuffleEnabled(false),
+    noBufferMode(false),
     size(params.buffered_ports.size()),
     // Event for processing the next network event
     nextNetworkEvent([this]{ processNextNetworkEvent(); },
@@ -314,7 +315,8 @@ Layer::processValues(
 
         uint64_t value_dest = -1;
         // Check if there's already a value in the buffer first
-        if (port->hasValues()) {
+        if (port->hasValues() && !noBufferMode) {
+            // Peek the next value from the port's queue
             value_dest = port->peekNextValue();
         } else {
             if (!fileMode) {
@@ -430,9 +432,20 @@ Layer::processValues(
         // Check if value can be sent in the current time slot
         if (value_dest == allowed_dest) {
             // Remove the value if it was from the buffer
+            Tick enqueue_tick = 0;
             if (port->hasValues()) {
-                port->getNextValue();
+                auto entry = port->getNextValue();
+                value_dest   = entry.dest;
+                enqueue_tick  = entry.enqueueTick;
+            } else {
+                enqueue_tick = curTick();
+            }
+
+            // We can clear out the buffer
+            if (!noBufferMode) {
+                port->clearQueue();
             }
+
             uint64_t payload;
             used_payloads.reserve(valuesPerPortPerWindow);
             while (used_payloads.size() < valuesPerPortPerWindow) {
@@ -472,9 +485,6 @@ Layer::processValues(
                     crosspointDelay +
                     variabilityCountingNetwork;
 
-                // Log the value processing details
-                stats.valueLatency.sample(payload_specific_delay);
-
                 DPRINTF(Layer,
                     "Processing value: src=%lu, dest=%lu, \
                     data=%lu, specific delay=%lu ps\n",
@@ -488,8 +498,8 @@ Layer::processValues(
 
                 // Schedule value delivery with payload-specific timing
                 schedule(new EventFunctionWrapper([this,
-                    src_addr, allowed_dest, p]() {
-                    deliverValue(src_addr, allowed_dest, p);
+                    src_addr, allowed_dest, p, enqueue_tick]() {
+                    deliverValue(src_addr, allowed_dest, p, enqueue_tick);
                 }, "deliverValueEvent"), curTick() + payload_specific_delay);
 
                 // Check if we've reached max values after processing this one
@@ -500,7 +510,11 @@ Layer::processValues(
             }
         } else if (!fileMode) {
             // Value not allowed in the current time slot
-            port->assignValue(value_dest);
+            if (!noBufferMode){
+                // If not in noBufferMode,
+                // assign the value to the buffer
+                port->assignValue(value_dest);
+            }
             // Increment missed values for the BufferedPort
             port->incrementMissedValues();
             stats.missedValuesPerBufferedPort.sample(
@@ -545,13 +559,20 @@ Layer::processValues(
 // Deliver a value to its destination port
 void
 Layer::deliverValue(uint64_t src_addr,
-    uint64_t dest_addr, uint64_t payload)
+    uint64_t dest_addr, uint64_t payload,
+    Tick enqueue_tick)
 {
+    Tick total_latency = curTick() - enqueue_tick;
+    DPRINTF(Layer,
+        "Value delivery: src=%lu, dest=%lu, data=%lu, latency=%lu\n",
+        src_addr, dest_addr, payload, total_latency
+    );
     // Find the destination port
     BufferedPort* dest_port = getBufferedPort(dest_addr);
     if (dest_port != nullptr) {
         // Receive data at the destination port
         dest_port->receiveData(payload, src_addr);
+        stats.valueLatency.sample(total_latency);
         DPRINTF(Layer,
             "Value delivered: src=%lu, dest=%lu, data=%lu\n",
             src_addr, dest_addr, payload
@@ -616,7 +637,8 @@ Layer::LayerStats::regStats()
     missedValuesPerBufferedPort.init(64);
 
     valueLatency.init(64)
-        .name("valueLatency");
+        .name("valueLatency")
+        .desc("End-to-end latency (ps) = buffer delay + network");
 }
 
 } // namespace gem5

src/network/layer.hh

@@ -79,6 +79,7 @@ private:
     bool isFinished;  // Flag to indicate if the layer has finished
     bool fileMode;  // Flag to indicate if a file is used for scheduling
     bool shuffleEnabled;  // Flag to indicate if shuffling is enabled
+    bool noBufferMode;  // Flag to indicate if no buffering is used
     std::string schedulePath;  // Path to the schedule file
     NetworkScheduler scheduler;  // Scheduler for the network
     SuperNetwork* superNetwork;  // Pointer to the super network
@@ -105,7 +106,8 @@ private:
     );
     // Method for delivering a value to its destination
     void deliverValue(uint64_t src_addr,
-        uint64_t dest_addr, uint64_t payload
+        uint64_t dest_addr, uint64_t payload,
+        Tick enqueue_tick
     );
 
     // Struct to hold statistics related to the Layer
@@ -218,6 +220,11 @@ public:
     }
 
     void setShuffle() { shuffleEnabled = true; }
+
+    void setNoBufferMode()
+    {
+        noBufferMode = true;
+    }
 };
 
 } // namespace gem5