rlc: adding latency metric to RLC UM in the uplink

Author: yagoda

include/srsran/rlc/rlc_rx_metrics.h

@@ -39,6 +39,7 @@ struct rlc_rx_metrics {
   size_t   num_pdu_bytes;      ///< Number of PDU bytes
   uint32_t num_lost_pdus;      ///< Number of dropped PDUs (reassembly timeout expiry or out of rx window)
   uint32_t num_malformed_pdus; ///< Number of malformed PDUs
+  uint32_t sdu_latency_us;     ///< total SDU latency (in us)>
 
   /// RLC mode of the entity
   rlc_mode mode;

lib/rlc/rlc_rx_metrics_container.h

@@ -72,6 +72,15 @@ class rlc_rx_metrics_container
     metrics.num_malformed_pdus += num_pdus_;
   }
 
+  void metrics_add_sdu_latency(uint32_t sdu_latency_us_)
+  {
+    if (not enabled) {
+      return;
+    }
+    std::lock_guard<std::mutex> lock(metrics_mutex);
+    metrics.sdu_latency_us += sdu_latency_us_;
+  }
+
   /// RLC AM specific metrics
   void metrics_add_ctrl_pdus(uint32_t num_ctrl_, uint32_t num_ctrl_pdu_bytes_)
   {

lib/rlc/rlc_rx_um_entity.cpp

@@ -47,7 +47,7 @@ rlc_rx_um_entity::rlc_rx_um_entity(gnb_du_id_t                       gnb_du_id,
 void rlc_rx_um_entity::handle_pdu(byte_buffer_slice buf)
 {
   metrics.metrics_add_pdus(1, buf.length());
-
+  auto start = std::chrono::high_resolution_clock::now();
   pcap.push_pdu(pcap_context, buf);
 
   rlc_um_pdu_header header = {};
@@ -81,6 +81,9 @@ void rlc_rx_um_entity::handle_pdu(byte_buffer_slice buf)
     // deliver to upper layer
     logger.log_info("RX SDU. sdu_len={}", sdu.value().length());
     metrics.metrics_add_sdus(1, sdu.value().length());
+    auto latency =
+        std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - start);
+    metrics.metrics_add_sdu_latency(latency.count() / 1000);
     upper_dn.on_new_sdu(std::move(sdu.value()));
     // Nothing else to do here ...
     return;
@@ -115,6 +118,9 @@ void rlc_rx_um_entity::handle_pdu(byte_buffer_slice buf)
       // Do not pass empty SDU to upper layers and continue as normal to maintain state
     } else {
       logger.log_info("RX SDU. sn={} sdu_len={}", header.sn, sdu.value().length());
+      auto latency = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() -
+                                                                          sdu_info.time_of_arrival);
+      metrics.metrics_add_sdu_latency(latency.count() / 1000);
       metrics.metrics_add_sdus(1, sdu.value().length());
       upper_dn.on_new_sdu(std::move(sdu.value()));
     }
@@ -274,8 +280,11 @@ bool rlc_rx_um_entity::handle_segment_data_sdu(const rlc_um_pdu_header& header,
   logger.log_debug("RX SDU segment. payload_len={} {}", payload.length(), header);
 
   // Add new SN to RX window if no segments have been received yet
-  rlc_rx_um_sdu_info& rx_sdu = rx_window->has_sn(header.sn) ? (*rx_window)[header.sn] : rx_window->add_sn(header.sn);
-
+  rlc_rx_um_sdu_info& rx_sdu = rx_window->has_sn(header.sn) ? (*rx_window)[header.sn] : ([&]() -> rlc_rx_um_sdu_info& {
+    rlc_rx_um_sdu_info& sdu = rx_window->add_sn(header.sn);
+    sdu.time_of_arrival     = std::chrono::high_resolution_clock::now();
+    return sdu;
+  })();
   // Create SDU segment, to be stored later
   rlc_rx_um_sdu_segment segment = {};
   segment.si                    = header.si;

lib/rlc/rlc_rx_um_entity.h

@@ -43,6 +43,8 @@ struct rlc_rx_um_sdu_info {
   bool has_gap = false;
   /// Buffer for set of SDU segments.
   segment_set_t segments;
+  /// Time of arrival of the first segment of the SDU.
+  std::chrono::system_clock::time_point time_of_arrival;
 };
 
 /// \brief Rx state variables