sched: extend unit tests for slice scheduler and rewrote the prioritization mechanism

Author: frankist

lib/scheduler/slicing/ran_slice_candidate.h

@@ -20,7 +20,10 @@ template <bool IsDl>
 class common_ran_slice_candidate
 {
 public:
-  common_ran_slice_candidate(ran_slice_instance& instance_) : inst(&instance_) {}
+  common_ran_slice_candidate(ran_slice_instance& instance_, unsigned max_rbs_ = 0) :
+    inst(&instance_), max_rbs(max_rbs_ == 0 ? inst->cfg.max_prb : max_rbs_)
+  {
+  }
 
   ran_slice_id_t                               id() const { return inst->id; }
   [[nodiscard]] const slice_rrm_policy_config& cfg() const { return inst->cfg; }
@@ -43,13 +46,14 @@ class common_ran_slice_candidate
   [[nodiscard]] unsigned remaining_rbs() const
   {
     if constexpr (IsDl) {
-      return inst->cfg.max_prb < inst->pdsch_rb_count ? 0 : inst->cfg.max_prb - inst->pdsch_rb_count;
+      return max_rbs < inst->pdsch_rb_count ? 0 : max_rbs - inst->pdsch_rb_count;
     }
-    return inst->cfg.max_prb < inst->pusch_rb_count ? 0 : inst->cfg.max_prb - inst->pusch_rb_count;
+    return max_rbs < inst->pusch_rb_count ? 0 : max_rbs - inst->pusch_rb_count;
   }
 
 protected:
-  ran_slice_instance* inst = nullptr;
+  ran_slice_instance* inst    = nullptr;
+  unsigned            max_rbs = 0;
 };
 
 } // namespace detail

lib/scheduler/slicing/ran_slice_instance.cpp

@@ -23,8 +23,6 @@ void ran_slice_instance::slot_indication()
 {
   pdsch_rb_count = 0;
   pusch_rb_count = 0;
-  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

@@ -21,43 +21,18 @@ namespace srsran {
 class ran_slice_instance
 {
 public:
-  constexpr static int skip_slice_prio    = std::numeric_limits<int>::min();
-  constexpr static int default_slice_prio = 0;
-
   ran_slice_instance(ran_slice_id_t id_, const cell_configuration& cell_cfg_, const slice_rrm_policy_config& cfg_);
 
   void slot_indication();
 
   bool active() const { return not bearers.empty(); }
 
-  int get_dl_prio()
-  {
-    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_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;
-  }
-
   /// Save PDSCH grant.
   void store_pdsch_grant(unsigned crbs) { pdsch_rb_count += crbs; }
 
   /// Save PUSCH grant.
   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 set_pdsch_scheduled() { pdsch_complete = true; }
-
-  /// Mark the allocation of PUSCH for this slice and the current slot as complete.
-  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); }
 
@@ -85,10 +60,6 @@ class ran_slice_instance
   unsigned pdsch_rb_count = 0;
   /// Counter of how many RBs have been scheduled for PUSCH in the current slot for this slice.
   unsigned pusch_rb_count = 0;
-
-private:
-  bool pdsch_complete = false;
-  bool pusch_complete = false;
 };
 
 } // namespace srsran

lib/scheduler/slicing/slice_scheduler.cpp

@@ -19,46 +19,40 @@ slice_scheduler::slice_scheduler(const cell_configuration& cell_cfg_) :
 {
   // Create a number of slices equal to the number of configured RRM Policy members + 1 (default slice).
   slices.reserve(cell_cfg.rrm_policy_members.size() + 1);
-  sorted_dl_prios.reserve(cell_cfg.rrm_policy_members.size() + 1);
-  sorted_ul_prios.reserve(cell_cfg.rrm_policy_members.size() + 1);
 
   // Create RAN slice instances.
   ran_slice_id_t id_count{0};
   // Default slice.
   slices.emplace_back(id_count, cell_cfg, slice_rrm_policy_config{});
-  slices.back().policy =
+  slices.back().inst.policy =
       create_scheduler_strategy(scheduler_strategy_params{"time_rr", &logger}, cell_cfg.expert_cfg.ue);
-  sorted_dl_prios.emplace_back(id_count);
-  sorted_ul_prios.emplace_back(id_count);
   ++id_count;
   // Configured RRM policy members
   for (const slice_rrm_policy_config& rrm : cell_cfg.rrm_policy_members) {
     slices.emplace_back(id_count, cell_cfg, rrm);
-    slices.back().policy =
+    slices.back().inst.policy =
         create_scheduler_strategy(scheduler_strategy_params{"time_rr", &logger}, cell_cfg.expert_cfg.ue);
-    sorted_dl_prios.emplace_back(id_count);
-    sorted_ul_prios.emplace_back(id_count);
     ++id_count;
   }
 }
 
 void slice_scheduler::slot_indication()
 {
+  slot_count++;
+
+  // Update the context of each slice.
   for (auto& slice : slices) {
-    slice.slot_indication();
+    slice.inst.slot_indication();
   }
 
-  // Compute slice priorities.
-  for (slice_prio_context& ctx : sorted_dl_prios) {
-    ctx.prio = slices[ctx.id.value()].get_dl_prio();
-  }
-  for (slice_prio_context& ctx : sorted_ul_prios) {
-    ctx.prio = slices[ctx.id.value()].get_ul_prio();
+  // Recompute the priority queues.
+  dl_prio_queue.clear();
+  ul_prio_queue.clear();
+  for (const auto& slice : slices) {
+    unsigned max_rbs = slice.inst.cfg.min_prb > 0 ? slice.inst.cfg.min_prb : slice.inst.cfg.max_prb;
+    dl_prio_queue.push(slice_candidate_context{slice.inst.id, slice.get_prio(true, slot_count, false), {0, max_rbs}});
+    ul_prio_queue.push(slice_candidate_context{slice.inst.id, slice.get_prio(false, slot_count, false), {0, max_rbs}});
   }
-
-  // Sort slices by descending priority.
-  std::sort(sorted_dl_prios.begin(), sorted_dl_prios.end(), std::greater<>{});
-  std::sort(sorted_ul_prios.begin(), sorted_ul_prios.end(), std::greater<>{});
 }
 
 void slice_scheduler::add_ue(const ue_configuration& ue_cfg)
@@ -87,83 +81,104 @@ void slice_scheduler::reconf_ue(const ue_configuration& next_ue_cfg, const ue_co
 void slice_scheduler::rem_ue(du_ue_index_t ue_idx)
 {
   for (auto& slice : slices) {
-    slice.rem_ue(ue_idx);
+    slice.inst.rem_ue(ue_idx);
   }
 }
 
 ran_slice_instance& slice_scheduler::get_slice(const rrm_policy_member& rrm)
 {
-  auto it = std::find_if(
-      slices.begin(), slices.end(), [&rrm](const ran_slice_instance& slice) { return slice.cfg.rrc_member == rrm; });
+  auto it = std::find_if(slices.begin() + 1, slices.end(), [&rrm](const ran_slice_sched_context& slice) {
+    return slice.inst.cfg.rrc_member == rrm;
+  });
   if (it == slices.end()) {
     // Slice with the provided RRM policy member was not found. Return default slice.
-    return slices.front();
+    return slices.front().inst;
   }
-  return *it;
+  return it->inst;
 }
 
-std::optional<dl_ran_slice_candidate> slice_scheduler::get_next_dl_candidate()
+template <bool IsDownlink>
+std::optional<std::conditional_t<IsDownlink, dl_ran_slice_candidate, ul_ran_slice_candidate>>
+slice_scheduler::get_next_candidate()
 {
-  if (slices.size() == 1) {
-    return create_dl_candidate();
-  }
-
-  // Check if the slice priority hasn't changed. If it did, recompute priorities.
-  slice_prio_context* slice_prio_ctxt = &sorted_dl_prios.front();
-  // Recompute priority
-  int prio = slices[slice_prio_ctxt->id.value()].get_dl_prio();
-  if (prio != slice_prio_ctxt->prio) {
-    // Priority changed
-    slice_prio_ctxt->prio = prio;
-    // Check if sort needs to be called again
-    // Note: This assumes that only the previous front slice was used in scheduling.
-    if (prio < sorted_dl_prios[1].prio) {
-      // Slices need to be reordered.
-      std::sort(sorted_dl_prios.begin(), sorted_dl_prios.end(), std::greater<>{});
+  slice_prio_queue& prio_queue = IsDownlink ? dl_prio_queue : ul_prio_queue;
+  while (not prio_queue.empty()) {
+    ran_slice_sched_context& chosen_slice = slices[prio_queue.top().id.value()];
+    interval<unsigned>       rb_lims      = prio_queue.top().rb_lims;
+    prio_queue.pop();
+
+    unsigned rb_count = IsDownlink ? chosen_slice.inst.pdsch_rb_count : chosen_slice.inst.pusch_rb_count;
+    if (not rb_lims.contains(rb_count)) {
+      // The slice has been scheduled in this slot with a number of RBs that is not within the limits for this
+      // candidate. This could happen, for instance, if the scheduler could not schedule all RBs of a candidate
+      // bounded between {0, minRB}. In this case, the second candidate for the same slice with bounds {minRB, maxRB}
+      // is skipped.
+      continue;
     }
-  }
 
-  return create_dl_candidate();
-}
+    const slice_rrm_policy_config& cfg = chosen_slice.inst.cfg;
+    if (cfg.min_prb != cfg.max_prb and rb_lims.stop() == cfg.min_prb) {
+      // For the special case when minRB ratio>0, the first candidate for this slice was bounded between {0, minRB}.
+      // We re-add the slice as a candidate, this time, with RB bounds {minRB, maxRB}.
+      priority_type prio = chosen_slice.get_prio(true, slot_count, true);
+      prio_queue.push(slice_candidate_context{chosen_slice.inst.id, prio, {cfg.min_prb, cfg.max_prb}});
+    }
 
-std::optional<ul_ran_slice_candidate> slice_scheduler::get_next_ul_candidate()
-{
-  if (slices.size() == 1) {
-    return create_ul_candidate();
-  }
+    // Save current slot count.
+    unsigned& count_to_set = IsDownlink ? chosen_slice.last_dl_slot : chosen_slice.last_ul_slot;
+    count_to_set           = slot_count;
 
-  // Check if the slice priority hasn't changed. If it did, recompute priorities.
-  slice_prio_context* slice_prio_ctxt = &sorted_ul_prios.front();
-  // Recompute priority
-  int prio = slices[slice_prio_ctxt->id.value()].get_ul_prio();
-  if (prio != slice_prio_ctxt->prio) {
-    // Priority changed
-    slice_prio_ctxt->prio = prio;
-    // Check if sort needs to be called again
-    // Note: This assumes that only the previous front slice was used in scheduling.
-    if (prio < sorted_ul_prios[1].prio) {
-      // Slices need to be reordered.
-      std::sort(sorted_ul_prios.begin(), sorted_ul_prios.end(), std::greater<>{});
-    }
+    // Return the candidate.
+    return std::conditional_t<IsDownlink, dl_ran_slice_candidate, ul_ran_slice_candidate>{chosen_slice.inst,
+                                                                                          rb_lims.stop()};
   }
+  return std::nullopt;
+}
 
-  return create_ul_candidate();
+std::optional<dl_ran_slice_candidate> slice_scheduler::get_next_dl_candidate()
+{
+  return get_next_candidate<true>();
 }
 
-std::optional<dl_ran_slice_candidate> slice_scheduler::create_dl_candidate()
+std::optional<ul_ran_slice_candidate> slice_scheduler::get_next_ul_candidate()
 {
-  if (sorted_dl_prios[0].prio != ran_slice_instance::skip_slice_prio) {
-    slices[sorted_dl_prios[0].id.value()].set_pdsch_scheduled();
-    return dl_ran_slice_candidate{slices[sorted_dl_prios[0].id.value()]};
-  }
-  return std::nullopt;
+  return get_next_candidate<false>();
 }
 
-std::optional<ul_ran_slice_candidate> slice_scheduler::create_ul_candidate()
+slice_scheduler::priority_type slice_scheduler::ran_slice_sched_context::get_prio(bool            is_dl,
+                                                                                  slot_count_type current_slot_count,
+                                                                                  bool            slice_resched) const
 {
-  if (sorted_ul_prios[0].prio != ran_slice_instance::skip_slice_prio) {
-    slices[sorted_ul_prios[0].id.value()].set_pusch_scheduled();
-    return ul_ran_slice_candidate{slices[sorted_ul_prios[0].id.value()]};
+  // Note: The positive integer representing the priority of a slice consists of a concatenation of three priority
+  // values:
+  // 1. slice traffic priority (16 bits). Differentiation of slices based on whether they have minimum required
+  // traffic agreements (e.g. minRB ratio).
+  // 2. delay priority (8 bits), which attributes the highest priority to slices that have not been scheduled for a
+  // long time
+  // 3. round-robin based on slot indication count (8 bits).
+
+  // Priority when slice has already reached its minimum RB ratio agreement.
+  constexpr static priority_type default_prio = 0x1U;
+  // Priority when slice still needs to reach its minimum RB ratio agreement.
+  constexpr static priority_type high_prio     = 0x2U;
+  constexpr static priority_type delay_bitsize = 8U;
+  constexpr static priority_type rr_bitsize    = 8U;
+
+  unsigned rb_count = is_dl ? inst.pdsch_rb_count : inst.pusch_rb_count;
+  if (not inst.active() or rb_count >= inst.cfg.max_prb) {
+    // If the slice is not in a state to be scheduled in this slot, return skip priority level.
+    return skip_prio;
   }
-  return std::nullopt;
+
+  // In case minRB > 0 and this is the first time the slice is proposed as a candidate, we give it a higher priority.
+  priority_type slice_prio = inst.cfg.min_prb > 0 and not slice_resched ? high_prio : default_prio;
+
+  // Increase priorities of slices that have not been scheduled for a long time.
+  unsigned      last_count = is_dl ? last_dl_slot : last_ul_slot;
+  priority_type delay_prio = (current_slot_count - last_count) & ((1U << delay_bitsize) - 1U);
+
+  // Round-robin across slices with the same slice and delay priorities.
+  priority_type rr_prio = (inst.id.value() % current_slot_count) & ((1U << rr_bitsize) - 1U);
+
+  return (slice_prio << (delay_bitsize + rr_bitsize)) + (delay_prio << rr_bitsize) + rr_prio;
 }