sched: pass cell config to sched metrics handler

Author: frankist

lib/scheduler/config/sched_config_manager.cpp

@@ -9,6 +9,7 @@
  */
 
 #include "sched_config_manager.h"
+#include "../logging/scheduler_metrics_handler.h"
 #include "../logging/scheduler_metrics_ue_configurator.h"
 #include "srsran/scheduler/config/scheduler_cell_config_validator.h"
 #include "srsran/scheduler/config/scheduler_ue_config_validator.h"
@@ -57,16 +58,17 @@ void ue_config_delete_event::reset()
   }
 }
 
-sched_config_manager::sched_config_manager(const scheduler_config& sched_cfg) :
+sched_config_manager::sched_config_manager(const scheduler_config&    sched_cfg,
+                                           scheduler_metrics_handler& metrics_handler_) :
   expert_params(sched_cfg.expert_params),
+  metrics_handler(metrics_handler_),
   config_notifier(sched_cfg.config_notifier),
   logger(srslog::fetch_basic_logger("SCHED"))
 {
   std::fill(ue_to_cell_group_index.begin(), ue_to_cell_group_index.end(), INVALID_DU_CELL_GROUP_INDEX);
 }
 
-const cell_configuration* sched_config_manager::add_cell(const sched_cell_configuration_request_message& msg,
-                                                         sched_metrics_ue_configurator& metrics_handler_)
+const cell_configuration* sched_config_manager::add_cell(const sched_cell_configuration_request_message& msg)
 {
   srsran_assert(msg.cell_index < MAX_NOF_DU_CELLS, "cell index={} is not valid", msg.cell_index);
   srsran_assert(not added_cells.contains(msg.cell_index), "cell={} already exists", msg.cell_index);
@@ -76,7 +78,9 @@ const cell_configuration* sched_config_manager::add_cell(const sched_cell_config
   srsran_assert(ret.has_value(), "Invalid cell configuration request message. Cause: {}", ret.error().c_str());
 
   added_cells.emplace(msg.cell_index, std::make_unique<cell_configuration>(expert_params, msg));
-  cell_metrics.emplace(msg.cell_index, &metrics_handler_);
+
+  cell_metrics_handler* cell_metrics = metrics_handler.add_cell(*added_cells[msg.cell_index]);
+  srsran_assert(cell_metrics != nullptr, "Unable to create metrics handler");
 
   return added_cells[msg.cell_index].get();
 }
@@ -189,17 +193,17 @@ void sched_config_manager::handle_ue_config_complete(du_ue_index_t ue_index, std
   if (next_cfg != nullptr) {
     // Creation/Reconfig succeeded.
 
+    cell_metrics_handler& cell_metrics = metrics_handler.at(next_cfg->pcell_common_cfg().cell_index);
     if (ue_cfg_list[ue_index] == nullptr) {
       // UE creation case.
-      cell_metrics[next_cfg->pcell_common_cfg().cell_index]->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);
+      cell_metrics.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);
     } else {
       // Reconfiguration case.
-      cell_metrics[next_cfg->pcell_common_cfg().cell_index]->handle_ue_reconfiguration(ue_index);
+      cell_metrics.handle_ue_reconfiguration(ue_index);
     }
 
     // Stores new UE config and deletes old config.
@@ -227,7 +231,8 @@ void sched_config_manager::handle_ue_delete_complete(du_ue_index_t ue_index)
   ue_cfg_list[ue_index].reset();
 
   // Remove UE from metrics.
-  cell_metrics[pcell_idx]->handle_ue_deletion(ue_index);
+  cell_metrics_handler& cell_metrics = metrics_handler.at(pcell_idx);
+  cell_metrics.handle_ue_deletion(ue_index);
 
   // Mark the UE as released.
   ue_to_cell_group_index[ue_index].store(INVALID_DU_CELL_GROUP_INDEX, std::memory_order_release);

lib/scheduler/config/sched_config_manager.h

@@ -18,7 +18,7 @@
 namespace srsran {
 
 class sched_config_manager;
-class sched_metrics_ue_configurator;
+class scheduler_metrics_handler;
 
 /// Event to create/reconfigure a UE in the scheduler.
 class ue_config_update_event
@@ -98,10 +98,9 @@ class sched_ue_configuration_handler
 class sched_config_manager
 {
 public:
-  sched_config_manager(const scheduler_config& sched_cfg_);
+  sched_config_manager(const scheduler_config& sched_cfg_, scheduler_metrics_handler& metrics_handler_);
 
-  const cell_configuration* add_cell(const sched_cell_configuration_request_message& msg,
-                                     sched_metrics_ue_configurator&                  metrics_handler_);
+  const cell_configuration* add_cell(const sched_cell_configuration_request_message& msg);
 
   ue_config_update_event add_ue(const sched_ue_creation_request_message& cfg_req);
 
@@ -132,15 +131,13 @@ class sched_config_manager
   void handle_ue_delete_complete(du_ue_index_t ue_index);
 
   const scheduler_expert_config expert_params;
+  scheduler_metrics_handler&    metrics_handler;
   sched_configuration_notifier& config_notifier;
   srslog::basic_logger&         logger;
 
   // List of common configs for the scheduler cells.
   cell_common_configuration_list added_cells;
 
-  // List of metrics handlers for each cell.
-  slotted_id_table<du_cell_index_t, sched_metrics_ue_configurator*, MAX_NOF_DU_CELLS> cell_metrics;
-
   std::array<std::unique_ptr<ue_configuration>, MAX_NOF_DU_UES> ue_cfg_list;
 
   /// Mapping of UEs to DU Cell Groups.

lib/scheduler/logging/scheduler_metric_handler.cpp

@@ -8,6 +8,7 @@
  *
  */
 
+#include "../config/cell_configuration.h"
 #include "scheduler_metrics_handler.h"
 #include "srsran/srslog/srslog.h"
 
@@ -373,14 +374,14 @@ scheduler_metrics_handler::scheduler_metrics_handler(msecs
 {
 }
 
-cell_metrics_handler* scheduler_metrics_handler::add_cell(du_cell_index_t cell_idx)
+cell_metrics_handler* scheduler_metrics_handler::add_cell(const cell_configuration& cell_cfg)
 {
-  if (cells.contains(cell_idx)) {
-    srslog::fetch_basic_logger("SCHED").warning("Cell={} already exists", cell_idx);
+  if (cells.contains(cell_cfg.cell_index)) {
+    srslog::fetch_basic_logger("SCHED").warning("Cell={} already exists", cell_cfg.cell_index);
     return nullptr;
   }
 
-  cells.emplace(cell_idx, report_period, notifier);
+  cells.emplace(cell_cfg.cell_index, report_period, notifier);
 
-  return &cells[cell_idx];
+  return &cells[cell_cfg.cell_index];
 }

lib/scheduler/logging/scheduler_metrics_handler.h

@@ -20,6 +20,8 @@
 
 namespace srsran {
 
+class cell_configuration;
+
 ///\brief Handler of scheduler slot metrics for a given cell.
 class cell_metrics_handler final : public harq_timeout_handler, public sched_metrics_ue_configurator
 {
@@ -167,7 +169,9 @@ class scheduler_metrics_handler
   /// \brief Creates a scheduler metrics handler. In case the metrics_report_period is zero, no metrics are reported.
   explicit scheduler_metrics_handler(msecs metrics_report_period, scheduler_metrics_notifier& notifier);
 
-  cell_metrics_handler* add_cell(du_cell_index_t cell_idx);
+  cell_metrics_handler* add_cell(const cell_configuration& cell_cfg);
+
+  cell_metrics_handler& at(du_cell_index_t cell_idx) { return cells[cell_idx]; }
 
 private:
   scheduler_metrics_notifier&     notifier;

lib/scheduler/scheduler_impl.cpp

@@ -18,18 +18,13 @@ scheduler_impl::scheduler_impl(const scheduler_config& sched_cfg_) :
   expert_params(sched_cfg_.expert_params),
   logger(srslog::fetch_basic_logger("SCHED")),
   metrics(expert_params.metrics_report_period, sched_cfg_.metrics_notifier),
-  cfg_mng(sched_cfg_)
+  cfg_mng(sched_cfg_, metrics)
 {
 }
 
 bool scheduler_impl::handle_cell_configuration_request(const sched_cell_configuration_request_message& msg)
 {
-  cell_metrics_handler* cell_metrics = metrics.add_cell(msg.cell_index);
-  if (cell_metrics == nullptr) {
-    return false;
-  }
-
-  const cell_configuration* cell_cfg = cfg_mng.add_cell(msg, *cell_metrics);
+  const cell_configuration* cell_cfg = cfg_mng.add_cell(msg);
   if (cell_cfg == nullptr) {
     return false;
   }
@@ -41,9 +36,9 @@ bool scheduler_impl::handle_cell_configuration_request(const sched_cell_configur
   }
 
   // Create a new cell scheduler instance.
-  cells.emplace(
-      msg.cell_index,
-      std::make_unique<cell_scheduler>(expert_params, msg, *cell_cfg, *groups[msg.cell_group_index], *cell_metrics));
+  cells.emplace(msg.cell_index,
+                std::make_unique<cell_scheduler>(
+                    expert_params, msg, *cell_cfg, *groups[msg.cell_group_index], metrics.at(msg.cell_index)));
 
   return true;
 }

tests/unittests/scheduler/test_utils/config_generators.cpp

@@ -52,7 +52,8 @@ test_sched_config_manager::test_sched_config_manager(const cell_config_builder_p
   cfg_notifier(std::make_unique<dummy_sched_configuration_notifier>()),
   metric_notifier(std::make_unique<dummy_scheduler_ue_metrics_notifier>()),
   ue_metrics_configurator(std::make_unique<dummy_sched_metrics_ue_configurator>()),
-  cfg_mng(scheduler_config{expert_cfg, *cfg_notifier, *metric_notifier})
+  metrics_handler(std::chrono::milliseconds{1000}, *metric_notifier),
+  cfg_mng(scheduler_config{expert_cfg, *cfg_notifier, *metric_notifier}, metrics_handler)
 {
   default_cell_req = test_helpers::make_default_sched_cell_configuration_request(builder_params);
   default_ue_req   = test_helpers::create_default_sched_ue_creation_request(builder_params, {lcid_t::LCID_MIN_DRB});
@@ -62,7 +63,7 @@ test_sched_config_manager::~test_sched_config_manager() {}
 
 const cell_configuration* test_sched_config_manager::add_cell(const sched_cell_configuration_request_message& msg)
 {
-  return cfg_mng.add_cell(msg, *ue_metrics_configurator);
+  return cfg_mng.add_cell(msg);
 }
 
 const ue_configuration* test_sched_config_manager::add_ue(const sched_ue_creation_request_message& cfg_req)

tests/unittests/scheduler/test_utils/config_generators.h

@@ -12,6 +12,7 @@
 
 #include "lib/du/du_high/du_manager/converters/scheduler_configuration_helpers.h"
 #include "lib/scheduler/config/sched_config_manager.h"
+#include "lib/scheduler/logging/scheduler_metrics_handler.h"
 #include "srsran/du/du_cell_config_helpers.h"
 #include "srsran/ran/duplex_mode.h"
 #include "srsran/ran/pucch/pucch_info.h"
@@ -24,6 +25,9 @@
 #include "srsran/support/test_utils.h"
 
 namespace srsran {
+
+class sched_metrics_ue_configurator;
+
 namespace test_helpers {
 
 inline sched_cell_configuration_request_message
@@ -341,6 +345,7 @@ class test_sched_config_manager
   std::unique_ptr<sched_configuration_notifier>  cfg_notifier;
   std::unique_ptr<scheduler_metrics_notifier>    metric_notifier;
   std::unique_ptr<sched_metrics_ue_configurator> ue_metrics_configurator;
+  scheduler_metrics_handler                      metrics_handler;
 
   sched_cell_configuration_request_message default_cell_req;
   sched_ue_creation_request_message        default_ue_req;

tests/unittests/scheduler/ue_scheduling/fallback_scheduler_test.cpp

@@ -10,6 +10,7 @@
 
 #include "lib/scheduler/common_scheduling/csi_rs_scheduler.h"
 #include "lib/scheduler/config/sched_config_manager.h"
+#include "lib/scheduler/logging/scheduler_metrics_handler.h"
 #include "lib/scheduler/logging/scheduler_result_logger.h"
 #include "lib/scheduler/pdcch_scheduling/pdcch_resource_allocator_impl.h"
 #include "lib/scheduler/pucch_scheduling/pucch_allocator_impl.h"
@@ -80,8 +81,9 @@ struct test_bench {
   scheduler_harq_timeout_dummy_handler    harq_timeout_handler;
   scheduler_ue_metrics_dummy_configurator metrics_ue_handler;
   cell_config_builder_params              builder_params;
+  scheduler_metrics_handler               metrics{std::chrono::milliseconds{0}, metrics_notif};
 
-  sched_config_manager      cfg_mng{scheduler_config{sched_cfg, dummy_notif, metrics_notif}};
+  sched_config_manager      cfg_mng{scheduler_config{sched_cfg, dummy_notif, metrics_notif}, metrics};
   const cell_configuration& cell_cfg;
 
   cell_resource_allocator       res_grid{cell_cfg};
@@ -101,7 +103,7 @@ struct test_bench {
                       const sched_cell_configuration_request_message& cell_req) :
     sched_cfg{sched_cfg_},
     builder_params{builder_params_},
-    cell_cfg{*[&]() { return cfg_mng.add_cell(cell_req, metrics_ue_handler); }()},
+    cell_cfg{*[&]() { return cfg_mng.add_cell(cell_req); }()},
     ue_alloc(expert_cfg, ue_db, srslog::fetch_basic_logger("SCHED", true)),
     fallback_sched(expert_cfg, cell_cfg, pdcch_sch, pucch_alloc, ue_db),
     csi_rs_sched(cell_cfg)

tests/unittests/scheduler/ue_scheduling/ue_grid_allocator_test.cpp

@@ -37,8 +37,7 @@ class ue_grid_allocator_tester : public ::testing::TestWithParam<duplex_mode>
           GetParam() == duplex_mode::FDD ? subcarrier_spacing::kHz15 : subcarrier_spacing::kHz30;
       cfg_builder_params.band           = band_helper::get_band_from_dl_arfcn(cfg_builder_params.dl_f_ref_arfcn);
       cfg_builder_params.channel_bw_mhz = bs_channel_bandwidth::MHz20;
-      auto* cfg = cfg_mng.add_cell(test_helpers::make_default_sched_cell_configuration_request(cfg_builder_params),
-                                   metrics_ue_handler);
+      auto* cfg = cfg_mng.add_cell(test_helpers::make_default_sched_cell_configuration_request(cfg_builder_params));
       srsran_assert(cfg != nullptr, "Cell configuration failed");
       return cfg;
     }()),
@@ -124,9 +123,10 @@ class ue_grid_allocator_tester : public ::testing::TestWithParam<duplex_mode>
   scheduler_ue_metrics_dummy_notifier     metrics_notif;
   scheduler_ue_metrics_dummy_configurator metrics_ue_handler;
   scheduler_harq_timeout_dummy_handler    harq_timeout_handler;
+  scheduler_metrics_handler               metrics{std::chrono::milliseconds{0}, metrics_notif};
 
   cell_config_builder_params cfg_builder_params;
-  sched_config_manager       cfg_mng{scheduler_config{sched_cfg, mac_notif, metrics_notif}};
+  sched_config_manager       cfg_mng{scheduler_config{sched_cfg, mac_notif, metrics_notif}, metrics};
   const cell_configuration&  cell_cfg;
 
   cell_harq_manager       cell_harqs{MAX_NOF_DU_UES,