sched: track PUSCH grant allocation on a per PUSCH slot basis in a slice

Author: herlesupreeth

lib/scheduler/slicing/ran_slice_candidate.h

@@ -20,8 +20,8 @@ template <bool IsDl>
 class common_ran_slice_candidate
 {
 public:
-  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_)
+  common_ran_slice_candidate(ran_slice_instance& instance_, slot_point slot_tx_, unsigned max_rbs_ = 0) :
+    inst(&instance_), max_rbs(max_rbs_ == 0 ? inst->cfg.max_prb : max_rbs_), slot_tx(slot_tx_)
   {
   }
 
@@ -40,7 +40,7 @@ class common_ran_slice_candidate
     if constexpr (IsDl) {
       inst->store_pdsch_grant(nof_rbs);
     } else {
-      inst->store_pusch_grant(nof_rbs);
+      inst->store_pusch_grant(nof_rbs, slot_tx);
     }
   }
 
@@ -50,12 +50,16 @@ class common_ran_slice_candidate
     if constexpr (IsDl) {
       return max_rbs < inst->pdsch_rb_count ? 0 : max_rbs - inst->pdsch_rb_count;
     }
-    return max_rbs < inst->pusch_rb_count ? 0 : max_rbs - inst->pusch_rb_count;
+    return max_rbs < inst->pusch_rb_count_per_slot[slot_tx.to_uint()]
+               ? 0
+               : max_rbs - inst->pusch_rb_count_per_slot[slot_tx.to_uint()];
   }
 
 protected:
   ran_slice_instance* inst    = nullptr;
   unsigned            max_rbs = 0;
+  /// Slot at which PUSCH/PDSCH needs to be scheduled for this slice candidate.
+  slot_point slot_tx;
 };
 
 } // namespace detail

lib/scheduler/slicing/ran_slice_instance.cpp

@@ -17,12 +17,16 @@ ran_slice_instance::ran_slice_instance(ran_slice_id_t                 id_,
                                        const slice_rrm_policy_config& cfg_) :
   id(id_), cell_cfg(&cell_cfg_), cfg(cfg_)
 {
+  std::fill(pusch_rb_count_per_slot.begin(), pusch_rb_count_per_slot.end(), 0);
 }
 
-void ran_slice_instance::slot_indication()
+void ran_slice_instance::slot_indication(slot_point slot_tx)
 {
   pdsch_rb_count = 0;
-  pusch_rb_count = 0;
+  // Clear RB count in previous slots.
+  for (unsigned count = 0; count < nof_slots_to_clear; ++count) {
+    pusch_rb_count_per_slot[(slot_tx - 1 - count).to_uint()] = 0;
+  }
 }
 
 void ran_slice_instance::rem_logical_channel(du_ue_index_t ue_idx, lcid_t lcid)

lib/scheduler/slicing/ran_slice_instance.h

@@ -10,6 +10,7 @@
 
 #pragma once
 
+#include "../../scheduler/cell/resource_grid.h"
 #include "../config/cell_configuration.h"
 #include "../ue_scheduling/ue_repository.h"
 #include "ran_slice_id.h"
@@ -21,18 +22,25 @@ namespace srsran {
 /// This class stores all the internal information relative to a RAN slice instantiation.
 class ran_slice_instance
 {
+  /// Number of slots for which allocated PUSCH grant is maintained.
+  static const size_t RING_ALLOCATOR_SIZE =
+      get_allocator_ring_size_gt_min(SCHEDULER_MAX_K2 + NTN_CELL_SPECIFIC_KOFFSET_MAX);
+
 public:
   ran_slice_instance(ran_slice_id_t id_, const cell_configuration& cell_cfg_, const slice_rrm_policy_config& cfg_);
 
-  void slot_indication();
+  void slot_indication(slot_point slot_tx);
 
   bool active() const { return not slice_ues.empty(); }
 
   /// 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; }
+  void store_pusch_grant(unsigned crbs, slot_point pusch_slot)
+  {
+    pusch_rb_count_per_slot[pusch_slot.to_uint()] += crbs;
+  }
 
   /// 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
@@ -65,8 +73,14 @@ class ran_slice_instance
 
   /// Counter of how many RBs have been scheduled for PDSCH in the current slot for this slice.
   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;
+  /// Ring of counters of how many RBs have been scheduled for PUSCH in a particular slot for this slice.
+  circular_array<unsigned, RING_ALLOCATOR_SIZE> pusch_rb_count_per_slot;
+
+  /// Nof. of previous slots in which RB count needs to be cleared in \c pusch_rb_count_per_slot upon receiving slot
+  /// indication.
+  /// \remark This is needed since slot_indication() is called only over DL slots.
+  unsigned nof_slots_to_clear =
+      cell_cfg->tdd_cfg_common.has_value() ? nof_slots_per_tdd_period(*cell_cfg->tdd_cfg_common) : 1;
 
 private:
   slice_ue_repository slice_ues;

lib/scheduler/slicing/slice_scheduler.cpp

@@ -10,6 +10,7 @@
 
 #include "slice_scheduler.h"
 #include "../policy/scheduler_policy_factory.h"
+#include "../support/pusch/pusch_td_resource_indices.h"
 #include "srsran/srslog/srslog.h"
 
 using namespace srsran;
@@ -41,24 +42,48 @@ slice_scheduler::slice_scheduler(const cell_configuration& cell_cfg_, ue_reposit
     slices.back().policy                       = create_scheduler_strategy(slice_scheduler_ue_expert_cfg);
     ++id_count;
   }
+
+  // NOTE: Below derivation assumes that only pusch-ConfigCommon includes pusch-TimeDomainAllocationList.
+  // NOTE: [Implementation-defined] In case of FDD, we use only single value of k2.
+  unsigned nof_slots = cell_cfg.is_tdd() ? nof_slots_per_tdd_period(*cell_cfg.tdd_cfg_common) : 1;
+  valid_pusch_td_list_per_slot.resize(nof_slots);
+  for (unsigned slot_period_idx = 0, e = nof_slots; slot_period_idx != e; ++slot_period_idx) {
+    slot_point pdcch_slot{to_numerology_value(cell_cfg.dl_cfg_common.init_dl_bwp.generic_params.scs), slot_period_idx};
+    if (cell_cfg.is_dl_enabled(pdcch_slot)) {
+      // TODO: Revisit when PUSCH time domain resource list is also defined in UE dedicated configuration.
+      valid_pusch_td_list_per_slot[slot_period_idx] = get_pusch_td_resource_indices(cell_cfg, pdcch_slot);
+    }
+  }
 }
 
-void slice_scheduler::slot_indication()
+void slice_scheduler::slot_indication(slot_point slot_tx)
 {
   slot_count++;
 
   // Update the context of each slice.
   for (auto& slice : slices) {
-    slice.inst.slot_indication();
+    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;
-    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}});
+    dl_prio_queue.push(slice_candidate_context{
+        slice.inst.id, slice.get_prio(true, slot_count, false, slot_tx), {0, 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});
+    }
   }
 }
 
@@ -189,9 +214,11 @@ slice_scheduler::get_next_candidate()
   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;
+    slot_point               slot_tx      = prio_queue.top().slot_tx;
     prio_queue.pop();
 
-    unsigned rb_count = IsDownlink ? chosen_slice.inst.pdsch_rb_count : chosen_slice.inst.pusch_rb_count;
+    unsigned rb_count =
+        IsDownlink ? chosen_slice.inst.pdsch_rb_count : chosen_slice.inst.pusch_rb_count_per_slot[slot_tx.to_uint()];
     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
@@ -204,17 +231,17 @@ slice_scheduler::get_next_candidate()
     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}});
+      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});
     }
 
     // Save current slot count.
     unsigned& count_to_set = IsDownlink ? chosen_slice.last_dl_slot : chosen_slice.last_ul_slot;
     count_to_set           = slot_count;
 
     // Return the candidate.
-    return std::conditional_t<IsDownlink, dl_ran_slice_candidate, ul_ran_slice_candidate>{chosen_slice.inst,
-                                                                                          rb_lims.stop()};
+    return std::conditional_t<IsDownlink, dl_ran_slice_candidate, ul_ran_slice_candidate>{
+        chosen_slice.inst, slot_tx, rb_lims.stop()};
   }
   return std::nullopt;
 }
@@ -231,7 +258,8 @@ 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) const
+                                                                                  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
   // values:
@@ -248,7 +276,7 @@ slice_scheduler::priority_type slice_scheduler::ran_slice_sched_context::get_pri
   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;
+  unsigned rb_count = is_dl ? inst.pdsch_rb_count : inst.pusch_rb_count_per_slot[slot_tx.to_uint()];
   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;

lib/scheduler/slicing/slice_scheduler.h

@@ -28,7 +28,7 @@ class slice_scheduler
   slice_scheduler(const cell_configuration& cell_cfg_, ue_repository& ues_);
 
   /// Reset the state of the slices.
-  void slot_indication();
+  void slot_indication(slot_point slot_tx);
 
   /// Update the state of the slice with the provided UE configs.
   void add_ue(du_ue_index_t ue_idx);
@@ -66,16 +66,19 @@ class slice_scheduler
     }
 
     /// Determines the slice candidate priority.
-    priority_type get_prio(bool is_dl, slot_count_type current_slot_count, bool slice_resched) const;
+    priority_type
+    get_prio(bool is_dl, slot_count_type current_slot_count, bool slice_resched, slot_point slot_tx) const;
   };
 
   struct slice_candidate_context {
     ran_slice_id_t     id;
     priority_type      prio;
     interval<unsigned> rb_lims;
+    /// Slot at which PUSCH/PDSCH needs to be scheduled for this slice candidate.
+    slot_point slot_tx;
 
-    slice_candidate_context(ran_slice_id_t id_, priority_type prio_, interval<unsigned> rb_lims_) :
-      id(id_), prio(prio_), rb_lims(rb_lims_)
+    slice_candidate_context(ran_slice_id_t id_, priority_type prio_, interval<unsigned> rb_lims_, slot_point slot_tx_) :
+      id(id_), prio(prio_), rb_lims(rb_lims_), slot_tx(slot_tx_)
     {
     }
 
@@ -122,6 +125,10 @@ class slice_scheduler
 
   ue_repository& ues;
 
+  /// Vector circularly indexed by slot with the list of applicable PUSCH time domain resources per slot.
+  /// NOTE: The list would be empty for UL slots.
+  std::vector<static_vector<unsigned, pusch_constants::MAX_NOF_PUSCH_TD_RES_ALLOCS>> valid_pusch_td_list_per_slot;
+
   std::vector<ran_slice_sched_context> slices;
 
   // Queue of slice candidates sorted by priority.

lib/scheduler/support/pusch/pusch_td_resource_indices.cpp

@@ -22,6 +22,12 @@ compute_pusch_td_resource_indices(span<const pusch_time_domain_resource_allocati
 {
   // Compute list of PUSCH time domain resource index list relevant for the PUSCH slot.
   static_vector<unsigned, pusch_constants::MAX_NOF_PUSCH_TD_RES_ALLOCS> pusch_td_res_index_list;
+  if (pusch_time_domain_list.empty()) {
+    return pusch_td_res_index_list;
+  }
+  // [Implementation-defined] Default PUSCH time domain resource index to use if no valid PUSCH time domain resource is
+  // found.
+  const unsigned default_pusch_td_res_index = 0;
 
   std::optional<unsigned> nof_full_ul_slots = std::nullopt;
   std::optional<unsigned> nof_full_dl_slots = std::nullopt;
@@ -53,6 +59,10 @@ compute_pusch_td_resource_indices(span<const pusch_time_domain_resource_allocati
     }
   }
 
+  if (pusch_td_res_index_list.empty()) {
+    pusch_td_res_index_list.push_back(default_pusch_td_res_index);
+  }
+
   return pusch_td_res_index_list;
 }
 

lib/scheduler/ue_scheduling/ue_scheduler_impl.cpp

@@ -48,7 +48,7 @@ void ue_scheduler_impl::run_sched_strategy(slot_point slot_tx, du_cell_index_t c
   }
 
   // Update slice context and compute slice priorities.
-  cells[cell_index]->slice_sched.slot_indication();
+  cells[cell_index]->slice_sched.slot_indication(slot_tx);
 
   // Perform round-robin prioritization of UL and DL scheduling. This gives unfair preference to DL over UL. This is
   // done to avoid the issue of sending wrong DAI value in DCI format 0_1 to UE while the PDSCH is allocated

tests/unittests/scheduler/policy/scheduler_policy_test.cpp

@@ -67,7 +67,7 @@ class base_scheduler_policy_test
     logger.set_context(next_slot.sfn(), next_slot.slot_index());
 
     grid_alloc.slot_indication(next_slot);
-    slice_sched.slot_indication();
+    slice_sched.slot_indication(next_slot);
 
     res_grid.slot_indication(next_slot);
     pdcch_alloc.slot_indication(next_slot);