sched: fix computation RB limits for slice candidate

Author: herlesupreeth

lib/scheduler/slicing/slice_scheduler.cpp

@@ -65,24 +65,30 @@ void slice_scheduler::slot_indication(slot_point slot_tx)
     slice.inst.slot_indication(slot_tx);
   }
 
-  // TODO: Update slices (store_grant()) with already allocated grant in the previous slots.
-
   // 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;
+    unsigned max_rbs = slice.inst.pdsch_rb_count <= slice.inst.cfg.min_prb and 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, slot_tx), {0, max_rbs}, slot_tx});
+        slice.inst.id, slice.get_prio(true, slot_count, slot_tx), {slice.inst.pdsch_rb_count, max_rbs}, slot_tx});
 
     // TODO: Revisit when PUSCH time domain resource list is also defined in UE dedicated configuration.
     span<const pusch_time_domain_resource_allocation> pusch_time_domain_list =
         cell_cfg.ul_cfg_common.init_ul_bwp.pusch_cfg_common.value().pusch_td_alloc_list;
     for (const unsigned pusch_td_res_idx :
          valid_pusch_td_list_per_slot[slot_tx.to_uint() % valid_pusch_td_list_per_slot.size()]) {
       slot_point pusch_slot = slot_tx + pusch_time_domain_list[pusch_td_res_idx].k2;
-      ul_prio_queue.push(slice_candidate_context{
-          slice.inst.id, slice.get_prio(false, slot_count, false, pusch_slot), {0, max_rbs}, pusch_slot});
+      max_rbs               = slice.inst.pusch_rb_count_per_slot[pusch_slot.to_uint()] <= slice.inst.cfg.min_prb and
+                        slice.inst.cfg.min_prb > 0
+                                  ? slice.inst.cfg.min_prb
+                                  : slice.inst.cfg.max_prb;
+      ul_prio_queue.push(slice_candidate_context{slice.inst.id,
+                                                 slice.get_prio(false, slot_count, pusch_slot),
+                                                 {slice.inst.pusch_rb_count_per_slot[pusch_slot.to_uint()], max_rbs},
+                                                 pusch_slot});
     }
   }
 }
@@ -222,17 +228,18 @@ slice_scheduler::get_next_candidate()
     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.
+      // bounded between {RBLimsMin, RBLimsMax}. In this case, the second candidate for the same slice with bounds
+      // {RBLimsMax, maxRB} is skipped.
       continue;
     }
 
     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(IsDownlink, slot_count, true, slot_tx);
-      prio_queue.push(slice_candidate_context{chosen_slice.inst.id, prio, {cfg.min_prb, cfg.max_prb}, slot_tx});
+    if (cfg.min_prb > 0 and 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 {RBLimsMin,
+      // RBLimsMax}. We re-add the slice as a candidate, this time, with RB bounds {RBLimsMax, maxRB}.
+      priority_type prio    = chosen_slice.get_prio(IsDownlink, slot_count, slot_tx);
+      unsigned      min_rbs = rb_count > 0 ? rb_count : cfg.min_prb;
+      prio_queue.push(slice_candidate_context{chosen_slice.inst.id, prio, {min_rbs, cfg.max_prb}, slot_tx});
     }
 
     // Save current slot count.
@@ -258,7 +265,6 @@ std::optional<ul_ran_slice_candidate> slice_scheduler::get_next_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,
                                                                                   slot_point      slot_tx) const
 {
   // Note: The positive integer representing the priority of a slice consists of a concatenation of three priority
@@ -282,8 +288,8 @@ slice_scheduler::priority_type slice_scheduler::ran_slice_sched_context::get_pri
     return skip_prio;
   }
 
-  // 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;
+  // In case minRB > 0 and minimum RB ratio agreement is not yet reached, we give it a higher priority.
+  priority_type slice_prio = inst.cfg.min_prb > 0 and rb_count < inst.cfg.min_prb ? 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;

lib/scheduler/slicing/slice_scheduler.h

@@ -66,8 +66,7 @@ class slice_scheduler
     }
 
     /// Determines the slice candidate priority.
-    priority_type
-    get_prio(bool is_dl, slot_count_type current_slot_count, bool slice_resched, slot_point slot_tx) const;
+    priority_type get_prio(bool is_dl, slot_count_type current_slot_count, slot_point slot_tx) const;
   };
 
   struct slice_candidate_context {

tests/unittests/scheduler/slicing/slice_scheduler_test.cpp

@@ -355,6 +355,7 @@ TEST_F(rb_ratio_slice_scheduler_test,
   // Original slice is selected again, now using maxRB ratio as the remaining RBs.
   ASSERT_EQ(next_dl_slice->id(), drb1_slice_id);
   ASSERT_EQ(next_dl_slice->remaining_rbs(), MAX_SLICE_RB - MIN_SLICE_RB);
+  next_dl_slice->store_grant(MAX_SLICE_RB - MIN_SLICE_RB);
 
   // No more slices to schedule.
   next_dl_slice = slice_sched.get_next_dl_candidate();
@@ -374,7 +375,7 @@ TEST_F(rb_ratio_slice_scheduler_test,
   next_dl_slice = slice_sched.get_next_dl_candidate();
   next_dl_slice->store_grant(MIN_SLICE_RB);
   next_dl_slice = slice_sched.get_next_dl_candidate();
-  next_dl_slice = slice_sched.get_next_dl_candidate();
+  next_dl_slice->store_grant(MAX_SLICE_RB - MIN_SLICE_RB);
   next_dl_slice = slice_sched.get_next_dl_candidate();
   ASSERT_FALSE(next_dl_slice.has_value());
 
@@ -390,6 +391,7 @@ TEST_F(rb_ratio_slice_scheduler_test,
   next_dl_slice = slice_sched.get_next_dl_candidate();
   ASSERT_EQ(next_dl_slice->id(), drb1_slice_id);
   ASSERT_EQ(next_dl_slice->remaining_rbs(), MAX_SLICE_RB - MIN_SLICE_RB);
+  next_dl_slice->store_grant(MAX_SLICE_RB - MIN_SLICE_RB);
   next_dl_slice = slice_sched.get_next_dl_candidate();
   ASSERT_FALSE(next_dl_slice.has_value());
 }