e2sm_kpm: adding support for DRB.AirIfDelayUl metric

Author: yagoda

include/srsran/scheduler/scheduler_metrics.h

@@ -36,6 +36,7 @@ struct scheduler_ue_metrics {
   sch_mcs_index                ul_mcs;
   double                       ul_prbs_used;
   double                       ul_brate_kbps;
+  double                       ul_delay_ms;
   unsigned                     ul_nof_ok;
   unsigned                     ul_nof_nok;
   unsigned                     bsr;

lib/e2/e2sm/e2sm_kpm/e2sm_kpm_du_meas_provider_impl.cpp

@@ -74,6 +74,10 @@ e2sm_kpm_du_meas_provider_impl::e2sm_kpm_du_meas_provider_impl(srs_du::f1ap_ue_i
       e2sm_kpm_supported_metric_t{
           NO_LABEL, ALL_LEVELS, true, &e2sm_kpm_du_meas_provider_impl::get_drb_rlc_sdu_transmitted_volume_ul});
 
+  supported_metrics.emplace(
+      "DRB.AirIfDelayUl",
+      e2sm_kpm_supported_metric_t{NO_LABEL, ALL_LEVELS, true, &e2sm_kpm_du_meas_provider_impl::get_delay_ul});
+
   // Check if the supported metrics are matching e2sm_kpm metrics definitions.
   check_e2sm_kpm_metrics_definitions(get_e2sm_kpm_28_552_metrics());
   check_e2sm_kpm_metrics_definitions(get_e2sm_kpm_oran_metrics());
@@ -337,6 +341,7 @@ bool e2sm_kpm_du_meas_provider_impl::get_rsrq(const asn1::e2sm::label_info_list_
 
   return meas_collected;
 }
+
 bool e2sm_kpm_du_meas_provider_impl::get_prb_avail_dl(const asn1::e2sm::label_info_list_l          label_info_list,
                                                       const std::vector<asn1::e2sm::ue_id_c>&      ues,
                                                       const std::optional<asn1::e2sm::cgi_c>       cell_global_id,
@@ -428,6 +433,24 @@ bool e2sm_kpm_du_meas_provider_impl::get_prb_use_perc_ul(const asn1::e2sm::label
 
   return meas_collected;
 }
+bool e2sm_kpm_du_meas_provider_impl::get_delay_ul(const asn1::e2sm::label_info_list_l          label_info_list,
+                                                  const std::vector<asn1::e2sm::ue_id_c>&      ues,
+                                                  const std::optional<asn1::e2sm::cgi_c>       cell_global_id,
+                                                  std::vector<asn1::e2sm::meas_record_item_c>& items)
+{
+  bool                 meas_collected = false;
+  scheduler_ue_metrics ue_metrics     = last_ue_metrics[0];
+  if ((label_info_list.size() > 1 or
+       (label_info_list.size() == 1 and not label_info_list[0].meas_label.no_label_present))) {
+    logger.debug("Metric: DRB.AirIfDelayUl supports only NO_LABEL label.");
+    return meas_collected;
+  }
+  meas_record_item_c meas_record_item;
+  meas_record_item.set_real().value = ue_metrics.ul_delay_ms;
+  items.push_back(meas_record_item);
+  meas_collected = true;
+  return meas_collected;
+}
 
 float e2sm_kpm_du_meas_provider_impl::bytes_to_kbits(float value)
 {

lib/e2/e2sm/e2sm_kpm/e2sm_kpm_du_meas_provider_impl.h

@@ -90,6 +90,7 @@ class e2sm_kpm_du_meas_provider_impl : public e2sm_kpm_meas_provider, public e2_
   metric_meas_getter_func_t get_prb_avail_ul;
   metric_meas_getter_func_t get_prb_use_perc_dl;
   metric_meas_getter_func_t get_prb_use_perc_ul;
+  metric_meas_getter_func_t get_delay_ul;
   metric_meas_getter_func_t get_drb_ul_success_rate;
   metric_meas_getter_func_t get_drb_rlc_packet_drop_rate_dl;
   metric_meas_getter_func_t get_drb_rlc_sdu_transmitted_volume_dl;

lib/scheduler/config/sched_config_manager.cpp

@@ -192,8 +192,11 @@ void sched_config_manager::handle_ue_config_complete(du_ue_index_t ue_index, std
 
     if (ue_cfg_list[ue_index] == nullptr) {
       // UE creation case.
-      metrics_handler.handle_ue_creation(
-          ue_index, next_cfg->crnti, next_cfg->pcell_common_cfg().pci, next_cfg->pcell_common_cfg().nof_dl_prbs);
+      metrics_handler.handle_ue_creation(ue_index,
+                                         next_cfg->crnti,
+                                         next_cfg->pcell_common_cfg().pci,
+                                         next_cfg->pcell_common_cfg().nof_dl_prbs,
+                                         next_cfg->pcell_common_cfg().nof_slots_per_frame);
     }
 
     // Stores new UE config and deletes old config.

lib/scheduler/logging/scheduler_metric_handler.cpp

@@ -21,13 +21,15 @@ scheduler_metrics_handler::scheduler_metrics_handler(msecs
 void scheduler_metrics_handler::handle_ue_creation(du_ue_index_t ue_index,
                                                    rnti_t        rnti,
                                                    pci_t         pcell_pci,
-                                                   unsigned      num_prbs)
+                                                   unsigned      num_prbs,
+                                                   unsigned      num_slots_per_frame)
 {
   ues.emplace(ue_index);
-  ues[ue_index].rnti     = rnti;
-  ues[ue_index].ue_index = ue_index;
-  ues[ue_index].pci      = pcell_pci;
-  ues[ue_index].nof_prbs = num_prbs;
+  ues[ue_index].rnti                = rnti;
+  ues[ue_index].ue_index            = ue_index;
+  ues[ue_index].pci                 = pcell_pci;
+  ues[ue_index].nof_prbs            = num_prbs;
+  ues[ue_index].num_slots_per_frame = num_slots_per_frame;
   rnti_to_ue_index_lookup.emplace(rnti, ue_index);
 }
 
@@ -253,6 +255,13 @@ void scheduler_metrics_handler::handle_slot_result(const sched_result&       slo
   decision_latency_hist[bin_idx]++;
 }
 
+void scheduler_metrics_handler::handle_ul_delay(du_ue_index_t ue_index, double delay)
+{
+  if (ues.contains(ue_index)) {
+    ues[ue_index].data.sum_ul_delay_ms += delay * (10 / (ues[ue_index].num_slots_per_frame));
+  }
+}
+
 void scheduler_metrics_handler::push_result(slot_point                sl_tx,
                                             const sched_result&       slot_result,
                                             std::chrono::microseconds slot_decision_latency)
@@ -297,6 +306,7 @@ scheduler_metrics_handler::ue_metric_context::compute_report(std::chrono::millis
   ret.pusch_rsrp_db = data.nof_pusch_rsrp_reports > 0 ? data.sum_pusch_rsrp / data.nof_pusch_rsrp_reports
                                                       : -std::numeric_limits<float>::infinity();
   ret.pucch_snr_db  = data.nof_pucch_snr_reports > 0 ? data.sum_pucch_snrs / data.nof_pucch_snr_reports : 0;
+  ret.ul_delay_ms   = data.sum_ul_delay_ms / data.count_crc_pdus;
   ret.bsr           = last_bsr;
   ret.dl_bs         = 0;
   for (const unsigned value : last_dl_bs) {

lib/scheduler/logging/scheduler_metrics_handler.h

@@ -42,6 +42,7 @@ class scheduler_metrics_handler final : public harq_timeout_handler, public sche
       double   sum_pusch_snrs         = 0;
       double   sum_pucch_snrs         = 0;
       double   sum_pusch_rsrp         = 0;
+      double   sum_ul_delay_ms        = 0;
       unsigned nof_pucch_snr_reports  = 0;
       unsigned nof_pusch_snr_reports  = 0;
       unsigned nof_pusch_rsrp_reports = 0;
@@ -59,6 +60,7 @@ class scheduler_metrics_handler final : public harq_timeout_handler, public sche
 
     pci_t                                  pci;
     unsigned                               nof_prbs;
+    unsigned                               num_slots_per_frame;
     du_ue_index_t                          ue_index;
     rnti_t                                 rnti;
     unsigned                               last_bsr = 0;
@@ -93,7 +95,11 @@ class scheduler_metrics_handler final : public harq_timeout_handler, public sche
   explicit scheduler_metrics_handler(msecs metrics_report_period, scheduler_metrics_notifier& notifier);
 
   /// \brief Register creation of a UE.
-  void handle_ue_creation(du_ue_index_t ue_index, rnti_t rnti, pci_t pcell_pci, unsigned num_prbs) override;
+  void handle_ue_creation(du_ue_index_t ue_index,
+                          rnti_t        rnti,
+                          pci_t         pcell_pci,
+                          unsigned      num_prbs,
+                          unsigned      num_slots_per_frame) override;
 
   /// \brief Register removal of a UE.
   void handle_ue_deletion(du_ue_index_t ue_index) override;
@@ -122,6 +128,8 @@ class scheduler_metrics_handler final : public harq_timeout_handler, public sche
   /// \brief Handle Error Indication reported to the scheduler for a given cell.
   void handle_error_indication();
 
+  void handle_ul_delay(du_ue_index_t ue_index, double delay);
+
   /// \brief Handle results stored in the scheduler result and push new entry.
   void push_result(slot_point sl_tx, const sched_result& slot_result, std::chrono::microseconds slot_decision_latency);
 

lib/scheduler/logging/scheduler_metrics_ue_configurator.h

@@ -23,7 +23,11 @@ class sched_metrics_ue_configurator
   virtual ~sched_metrics_ue_configurator() = default;
 
   /// Adds a new UE to the reported metrics.
-  virtual void handle_ue_creation(du_ue_index_t ue_index, rnti_t rnti, pci_t pcell_pci, unsigned num_prbs) = 0;
+  virtual void handle_ue_creation(du_ue_index_t ue_index,
+                                  rnti_t        rnti,
+                                  pci_t         pcell_pci,
+                                  unsigned      num_prbs,
+                                  unsigned      num_slots_per_frame) = 0;
 
   /// Removes a UE from the reported metrics.
   virtual void handle_ue_deletion(du_ue_index_t ue_index) = 0;

lib/scheduler/ue_scheduling/ue_event_manager.cpp

@@ -303,11 +303,11 @@ void ue_event_manager::handle_ul_phr_indication(const ul_phr_indication_message&
 void ue_event_manager::handle_crc_indication(const ul_crc_indication& crc_ind)
 {
   srsran_assert(cell_exists(crc_ind.cell_index), "Invalid cell index");
-
+  int slot_delay = last_sl - crc_ind.sl_rx;
   for (unsigned i = 0, e = crc_ind.crcs.size(); i != e; ++i) {
     cell_specific_events[crc_ind.cell_index].emplace(
         crc_ind.crcs[i].ue_index,
-        [this, sl_rx = crc_ind.sl_rx, crc = crc_ind.crcs[i]](ue_cell& ue_cc) {
+        [this, slot_delay, sl_rx = crc_ind.sl_rx, crc = crc_ind.crcs[i]](ue_cell& ue_cc) {
           const int tbs = ue_cc.handle_crc_pdu(sl_rx, crc);
           if (tbs < 0) {
             return;
@@ -325,6 +325,7 @@ void ue_event_manager::handle_crc_indication(const ul_crc_indication& crc_ind)
 
           // Notify metrics handler.
           metrics_handler.handle_crc_indication(crc, units::bytes{(unsigned)tbs});
+          metrics_handler.handle_ul_delay(crc.ue_index, slot_delay);
         },
         "CRC",
         true);

tests/unittests/scheduler/scheduler_metrics_handler_test.cpp

@@ -29,7 +29,7 @@ class scheduler_metrics_handler_tester : public ::testing::Test
       std::chrono::milliseconds period = std::chrono::milliseconds{test_rgen::uniform_int<unsigned>(2, 100)}) :
     report_period(period), metrics(period, metrics_notif)
   {
-    metrics.handle_ue_creation(test_ue_index, to_rnti(0x4601), pci_t{0}, nof_prbs);
+    metrics.handle_ue_creation(test_ue_index, to_rnti(0x4601), pci_t{0}, nof_prbs, num_slots_per_frame);
   }
 
   void run_slot(const sched_result& sched_res, std::chrono::microseconds latency = std::chrono::microseconds{0})
@@ -54,8 +54,9 @@ class scheduler_metrics_handler_tester : public ::testing::Test
   du_ue_index_t test_ue_index = to_du_ue_index(test_rgen::uniform_int<unsigned>(0, MAX_NOF_DU_UES - 1));
 
   slot_point next_sl_tx{0, test_rgen::uniform_int<unsigned>(0, 10239)};
-  unsigned   slot_count = 0;
-  unsigned   nof_prbs   = 100;
+  unsigned   slot_count          = 0;
+  unsigned   nof_prbs            = 100;
+  unsigned   num_slots_per_frame = 10;
 };
 
 TEST_F(scheduler_metrics_handler_tester, metrics_sent_with_defined_periodicity)

tests/unittests/scheduler/test_utils/config_generators.cpp

@@ -32,7 +32,13 @@ class dummy_scheduler_ue_metrics_notifier : public scheduler_metrics_notifier
 class dummy_sched_metrics_ue_configurator : public sched_metrics_ue_configurator
 {
 public:
-  void handle_ue_creation(du_ue_index_t ue_index, rnti_t rnti, pci_t pcell_pci, unsigned num_prbs) override {}
+  void handle_ue_creation(du_ue_index_t ue_index,
+                          rnti_t        rnti,
+                          pci_t         pcell_pci,
+                          unsigned      num_prbs,
+                          unsigned      num_slots_per_frame) override
+  {
+  }
   void handle_ue_deletion(du_ue_index_t ue_index) override {}
 };