sched: unit test for default slice scheduler

Author: frankist

lib/scheduler/slicing/ran_slice_candidate.h

@@ -19,21 +19,8 @@ namespace detail {
 template <bool IsDl>
 class common_ran_slice_candidate
 {
-  struct candidate_deleter {
-    void operator()(ran_slice_instance* p)
-    {
-      if (p != nullptr) {
-        if constexpr (IsDl) {
-          p->pdsch_completed();
-        } else {
-          p->pusch_completed();
-        }
-      }
-    }
-  };
-
 public:
-  common_ran_slice_candidate(ran_slice_instance* instance_) : inst(instance_, candidate_deleter{}) {}
+  common_ran_slice_candidate(ran_slice_instance& instance_) : inst(&instance_) {}
 
   ran_slice_id_t                               id() const { return inst->id; }
   [[nodiscard]] const slice_rrm_policy_config& cfg() const { return inst->cfg; }
@@ -42,9 +29,6 @@ class common_ran_slice_candidate
   bool is_candidate(du_ue_index_t ue_idx) const { return inst->contains(ue_idx); }
   bool is_candidate(du_ue_index_t ue_idx, lcid_t lcid) const { return inst->contains(ue_idx, lcid); }
 
-  /// Signal that the allocations for this slice are complete.
-  void clear() { inst.reset(); }
-
   /// Register that a new grant was allocated for a given UE.
   void store_grant(unsigned nof_rbs)
   {
@@ -65,7 +49,7 @@ class common_ran_slice_candidate
   }
 
 protected:
-  std::unique_ptr<ran_slice_instance, candidate_deleter> inst;
+  ran_slice_instance* inst = nullptr;
 };
 
 } // namespace detail

lib/scheduler/slicing/ran_slice_id.h

@@ -17,6 +17,6 @@ namespace srsran {
 
 /// RAN slice identifier that should be unique for a given cell,PLMN,S-NSSAI.
 struct ran_slice_id_tag {};
-using ran_slice_id_t = strong_type<uint8_t, struct ran_slice_id_tag, strong_increment_decrement>;
+using ran_slice_id_t = strong_type<uint8_t, struct ran_slice_id_tag, strong_increment_decrement, strong_equality>;
 
 } // namespace srsran

lib/scheduler/slicing/ran_slice_instance.cpp

@@ -23,8 +23,8 @@ void ran_slice_instance::slot_indication()
 {
   pdsch_rb_count = 0;
   pusch_rb_count = 0;
-  pdsch_stopped  = false;
-  pusch_stopped  = false;
+  pdsch_complete = false;
+  pusch_complete = false;
 }
 
 void ran_slice_instance::add_logical_channel(du_ue_index_t ue_idx, lcid_t lcid)

lib/scheduler/slicing/ran_slice_instance.h

@@ -32,15 +32,15 @@ class ran_slice_instance
 
   int get_dl_prio()
   {
-    if (not active() or pdsch_stopped or cfg.max_prb <= pdsch_rb_count) {
+    if (not active() or pdsch_complete or cfg.max_prb <= pdsch_rb_count) {
       return skip_slice_prio;
     }
     return cfg.min_prb > pdsch_rb_count ? cfg.min_prb - pdsch_rb_count : default_slice_prio;
   }
 
   int get_ul_prio()
   {
-    if (not active() or pusch_stopped or cfg.max_prb <= pusch_rb_count) {
+    if (not active() or pusch_complete or cfg.max_prb <= pusch_rb_count) {
       return skip_slice_prio;
     }
     return cfg.min_prb > pusch_rb_count ? cfg.min_prb - pusch_rb_count : default_slice_prio;
@@ -53,10 +53,10 @@ class ran_slice_instance
   void store_pusch_grant(unsigned crbs) { pusch_rb_count += crbs; }
 
   /// Mark the allocation of PDSCH for this slice and the current slot as complete.
-  void pdsch_completed() { pdsch_stopped = true; }
+  void set_pdsch_scheduled() { pdsch_complete = true; }
 
   /// Mark the allocation of PUSCH for this slice and the current slot as complete.
-  void pusch_completed() { pusch_stopped = true; }
+  void set_pusch_scheduled() { pusch_complete = true; }
 
   /// Determine if at least one bearer of the given UE is currently managed by this slice.
   bool contains(du_ue_index_t ue_idx) const { return bearers.contains(ue_idx); }
@@ -87,8 +87,8 @@ class ran_slice_instance
   unsigned pusch_rb_count = 0;
 
 private:
-  bool pdsch_stopped = false;
-  bool pusch_stopped = false;
+  bool pdsch_complete = false;
+  bool pusch_complete = false;
 };
 
 } // namespace srsran

lib/scheduler/slicing/slice_scheduler.cpp

@@ -14,7 +14,7 @@
 
 using namespace srsran;
 
-slice_scheduler::slice_scheduler(const cell_configuration& cell_cfg_, const slice_rrm_policy_config& cfg_) :
+slice_scheduler::slice_scheduler(const cell_configuration& cell_cfg_) :
   cell_cfg(cell_cfg_), logger(srslog::fetch_basic_logger("SCHED"))
 {
   // Create a number of slices equal to the number of configured RRM Policy members + 1 (default slice).
@@ -61,28 +61,26 @@ void slice_scheduler::slot_indication()
   std::sort(sorted_ul_prios.begin(), sorted_ul_prios.end(), std::greater<>{});
 }
 
-void slice_scheduler::add_ue(du_ue_index_t ue_idx, const ue_configuration& ue_cfg)
+void slice_scheduler::add_ue(const ue_configuration& ue_cfg)
 {
   for (const logical_channel_config& lc_cfg : ue_cfg.logical_channels()) {
     ran_slice_instance& sl_inst = get_slice(lc_cfg.rrm_policy);
-    sl_inst.add_logical_channel(ue_idx, lc_cfg.lcid);
+    sl_inst.add_logical_channel(ue_cfg.ue_index, lc_cfg.lcid);
   }
 }
 
-void slice_scheduler::reconf_ue(du_ue_index_t           ue_idx,
-                                const ue_configuration& next_ue_cfg,
-                                const ue_configuration& prev_ue_cfg)
+void slice_scheduler::reconf_ue(const ue_configuration& next_ue_cfg, const ue_configuration& prev_ue_cfg)
 {
   // Remove old bearers.
   for (const logical_channel_config& lc_cfg : prev_ue_cfg.logical_channels()) {
     ran_slice_instance& sl_inst = get_slice(lc_cfg.rrm_policy);
-    sl_inst.rem_logical_channel(ue_idx, lc_cfg.lcid);
+    sl_inst.rem_logical_channel(prev_ue_cfg.ue_index, lc_cfg.lcid);
   }
 
   // Add new bearers.
   for (const logical_channel_config& lc_cfg : next_ue_cfg.logical_channels()) {
     ran_slice_instance& sl_inst = get_slice(lc_cfg.rrm_policy);
-    sl_inst.add_logical_channel(ue_idx, lc_cfg.lcid);
+    sl_inst.add_logical_channel(prev_ue_cfg.ue_index, lc_cfg.lcid);
   }
 }
 
@@ -104,7 +102,7 @@ ran_slice_instance& slice_scheduler::get_slice(const rrm_policy_member& rrm)
   return *it;
 }
 
-dl_ran_slice_candidate slice_scheduler::get_next_dl_candidate()
+std::optional<dl_ran_slice_candidate> slice_scheduler::get_next_dl_candidate()
 {
   if (slices.size() == 1) {
     return create_dl_candidate();
@@ -128,7 +126,7 @@ dl_ran_slice_candidate slice_scheduler::get_next_dl_candidate()
   return create_dl_candidate();
 }
 
-ul_ran_slice_candidate slice_scheduler::get_next_ul_candidate()
+std::optional<ul_ran_slice_candidate> slice_scheduler::get_next_ul_candidate()
 {
   if (slices.size() == 1) {
     return create_ul_candidate();
@@ -152,14 +150,22 @@ ul_ran_slice_candidate slice_scheduler::get_next_ul_candidate()
   return create_ul_candidate();
 }
 
-dl_ran_slice_candidate slice_scheduler::create_dl_candidate()
+std::optional<dl_ran_slice_candidate> slice_scheduler::create_dl_candidate()
 {
-  bool has_candidates = sorted_dl_prios[0].prio != ran_slice_instance::skip_slice_prio;
-  return dl_ran_slice_candidate{has_candidates ? &slices[sorted_dl_prios[0].id.value()] : nullptr};
+  if (sorted_dl_prios[0].prio != ran_slice_instance::skip_slice_prio) {
+    slices[sorted_dl_prios[0].id.value()].set_pdsch_scheduled();
+    sorted_dl_prios[0].prio = ran_slice_instance::skip_slice_prio;
+    return dl_ran_slice_candidate{slices[sorted_dl_prios[0].id.value()]};
+  }
+  return std::nullopt;
 }
 
-ul_ran_slice_candidate slice_scheduler::create_ul_candidate()
+std::optional<ul_ran_slice_candidate> slice_scheduler::create_ul_candidate()
 {
-  bool has_candidates = sorted_ul_prios[0].prio != ran_slice_instance::skip_slice_prio;
-  return ul_ran_slice_candidate{has_candidates ? &slices[sorted_ul_prios[0].id.value()] : nullptr};
+  if (sorted_ul_prios[0].prio != ran_slice_instance::skip_slice_prio) {
+    slices[sorted_ul_prios[0].id.value()].set_pusch_scheduled();
+    sorted_ul_prios[0].prio = ran_slice_instance::skip_slice_prio;
+    return ul_ran_slice_candidate{slices[sorted_ul_prios[0].id.value()]};
+  }
+  return std::nullopt;
 }

lib/scheduler/slicing/slice_scheduler.h

@@ -20,21 +20,24 @@ namespace srsran {
 class slice_scheduler
 {
 public:
-  slice_scheduler(const cell_configuration& cell_cfg_, const slice_rrm_policy_config& cfg_);
+  slice_scheduler(const cell_configuration& cell_cfg_);
 
   /// Reset the state of the slices.
   void slot_indication();
 
   /// Update the state of the slice with the provided UE configs.
-  void add_ue(du_ue_index_t ue_idx, const ue_configuration& ue_cfg);
-  void reconf_ue(du_ue_index_t ue_idx, const ue_configuration& next_ue_cfg, const ue_configuration& prev_ue_cfg);
+  void add_ue(const ue_configuration& ue_cfg);
+  void reconf_ue(const ue_configuration& next_ue_cfg, const ue_configuration& prev_ue_cfg);
   void rem_ue(du_ue_index_t ue_idx);
 
   /// Get next RAN slice for PDSCH scheduling.
-  dl_ran_slice_candidate get_next_dl_candidate();
+  std::optional<dl_ran_slice_candidate> get_next_dl_candidate();
 
   /// Get next RAN slice for PUSCH scheduling.
-  ul_ran_slice_candidate get_next_ul_candidate();
+  std::optional<ul_ran_slice_candidate> get_next_ul_candidate();
+
+  size_t                         nof_slices() const { return slices.size(); }
+  const slice_rrm_policy_config& slice_config(ran_slice_id_t id) const { return slices[id.value()].cfg; }
 
 private:
   struct slice_prio_context {
@@ -51,8 +54,8 @@ class slice_scheduler
 
   ran_slice_instance& get_slice(const rrm_policy_member& rrm);
 
-  dl_ran_slice_candidate create_dl_candidate();
-  ul_ran_slice_candidate create_ul_candidate();
+  std::optional<dl_ran_slice_candidate> create_dl_candidate();
+  std::optional<ul_ran_slice_candidate> create_ul_candidate();
 
   const cell_configuration& cell_cfg;
   srslog::basic_logger&     logger;

tests/unittests/scheduler/CMakeLists.txt

@@ -18,6 +18,7 @@ add_subdirectory(ue_scheduling)
 add_subdirectory(uci_and_pucch)
 add_subdirectory(policy)
 add_subdirectory(config)
+add_subdirectory(slicing)
 
 add_executable(sched_no_ue_test scheduler_no_ue_test.cpp)
 target_link_libraries(sched_no_ue_test srsran_sched

tests/unittests/scheduler/slicing/CMakeLists.txt

@@ -0,0 +1,18 @@
+#
+# Copyright 2021-2024 Software Radio Systems Limited
+#
+# By using this file, you agree to the terms and conditions set
+# forth in the LICENSE file which can be found at the top level of
+# the distribution.
+#
+
+add_executable(slice_scheduler_test slice_scheduler_test.cpp)
+target_link_libraries(slice_scheduler_test
+        srsran_sched
+        scheduler_test_utils
+        scheduler_test_suite
+        mac_configuration_helpers
+        gtest
+        gtest_main
+)
+add_test(slice_scheduler_test slice_scheduler_test)

tests/unittests/scheduler/slicing/slice_scheduler_test.cpp

@@ -0,0 +1,129 @@
+/*
+ *
+ * Copyright 2021-2024 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "lib/scheduler/slicing/slice_scheduler.h"
+#include "tests/unittests/scheduler/test_utils/config_generators.h"
+#include "srsran/srslog/srslog.h"
+#include <gtest/gtest.h>
+
+using namespace srsran;
+
+class slice_scheduler_test : public ::testing::Test
+{
+protected:
+  slice_scheduler_test(const std::vector<slice_rrm_policy_config>& rrm_policy_members = {}) :
+    test_cfg(
+        []() {
+          cell_config_builder_params params{};
+          params.scs_common     = subcarrier_spacing::kHz30;
+          params.channel_bw_mhz = bs_channel_bandwidth_fr1::MHz100;
+          params.dl_arfcn       = 520000;
+          params.band           = nr_band::n41;
+          return params;
+        }(),
+        scheduler_expert_config{}),
+    cell_cfg([this, rrm_policy_members]() -> const cell_configuration& {
+      auto req               = test_cfg.get_default_cell_config_request();
+      req.rrm_policy_members = rrm_policy_members;
+      return *test_cfg.add_cell(req);
+    }())
+  {
+    logger.set_level(srslog::basic_levels::debug);
+    srslog::init();
+  }
+
+  ~slice_scheduler_test() { srslog::flush(); }
+
+  const ue_configuration* add_ue(du_ue_index_t ue_idx)
+  {
+    auto req                       = test_cfg.get_default_ue_config_request();
+    req.ue_index                   = ue_idx;
+    req.crnti                      = to_rnti(0x4601 + ue_idx);
+    req.starts_in_fallback         = false;
+    const ue_configuration* ue_cfg = test_cfg.add_ue(req);
+
+    slice_sched.add_ue(*ue_cfg);
+
+    return ue_cfg;
+  }
+
+  srslog::basic_logger&                   logger = srslog::fetch_basic_logger("TEST");
+  test_helpers::test_sched_config_manager test_cfg;
+  const cell_configuration&               cell_cfg;
+
+  slice_scheduler slice_sched{cell_cfg};
+};
+
+class default_slice_scheduler_test : public slice_scheduler_test
+{};
+
+TEST_F(default_slice_scheduler_test, if_no_rrm_policy_cfg_exists_then_only_default_slice_is_created)
+{
+  ASSERT_EQ(slice_sched.nof_slices(), 1);
+  ASSERT_EQ(slice_sched.slice_config(ran_slice_id_t{0}).min_prb, 0);
+  ASSERT_EQ(slice_sched.slice_config(ran_slice_id_t{0}).max_prb, MAX_NOF_PRBS);
+}
+
+TEST_F(default_slice_scheduler_test, when_no_lcid_exists_then_default_slice_is_not_a_candidate)
+{
+  slice_sched.slot_indication();
+
+  auto next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_FALSE(next_dl_slice.has_value());
+
+  auto next_ul_slice = slice_sched.get_next_ul_candidate();
+  ASSERT_FALSE(next_ul_slice.has_value());
+}
+
+TEST_F(default_slice_scheduler_test, when_lcid_is_part_of_default_slice_then_default_slice_is_valid_candidate)
+{
+  this->add_ue(to_du_ue_index(0));
+  slice_sched.slot_indication();
+
+  auto next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_TRUE(next_dl_slice.has_value());
+  ASSERT_EQ(next_dl_slice->id(), ran_slice_id_t{0});
+  ASSERT_TRUE(next_dl_slice->is_candidate(to_du_ue_index(0)));
+  ASSERT_TRUE(next_dl_slice->is_candidate(to_du_ue_index(0), lcid_t::LCID_SRB1));
+
+  auto next_ul_slice = slice_sched.get_next_ul_candidate();
+  ASSERT_TRUE(next_ul_slice.has_value());
+  ASSERT_EQ(next_ul_slice->id(), ran_slice_id_t{0});
+  ASSERT_TRUE(next_ul_slice->is_candidate(to_du_ue_index(0)));
+  ASSERT_TRUE(next_ul_slice->is_candidate(to_du_ue_index(0), lcid_t::LCID_SRB1));
+}
+
+TEST_F(default_slice_scheduler_test,
+       when_candidate_instance_goes_out_of_scope_then_it_stops_being_a_candidate_for_the_same_slot)
+{
+  this->add_ue(to_du_ue_index(0));
+  slice_sched.slot_indication();
+
+  auto next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_TRUE(next_dl_slice.has_value());
+  ASSERT_EQ(next_dl_slice->id(), ran_slice_id_t{0});
+
+  next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_FALSE(next_dl_slice.has_value());
+}
+
+TEST_F(default_slice_scheduler_test, when_candidate_instance_goes_out_of_scope_then_it_can_be_a_candidate_for_next_slot)
+{
+  this->add_ue(to_du_ue_index(0));
+
+  slice_sched.slot_indication();
+  auto next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_TRUE(next_dl_slice.has_value());
+
+  slice_sched.slot_indication();
+  next_dl_slice = slice_sched.get_next_dl_candidate();
+  ASSERT_TRUE(next_dl_slice.has_value());
+  ASSERT_EQ(next_dl_slice->id(), ran_slice_id_t{0});
+}