sched: fix pusch allocation on slots with SRS

Signed-off-by: Carlo Galiotto <[email protected]>

Author: carlo-gal

lib/scheduler/slicing/inter_slice_scheduler.cpp

@@ -136,6 +136,7 @@ void inter_slice_scheduler::slot_indication(slot_point slot_tx, const cell_resou
   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 auto& slice : slices) {
+    std::optional<unsigned> allocated_k2;
     for (const unsigned pusch_td_res_idx : slot_ring[slot_tx.count() % slot_ring.size()].valid_pusch_td_list) {
       unsigned pusch_delay = pusch_time_domain_list[pusch_td_res_idx].k2 + cell_cfg.ntn_cs_koffset;
       const cell_slot_resource_allocator& pusch_alloc = res_grid[pusch_delay];
@@ -147,6 +148,12 @@ void inter_slice_scheduler::slot_indication(slot_point slot_tx, const cell_resou
         continue;
       }
 
+      if (allocated_k2.has_value() and allocated_k2.value() == pusch_time_domain_list[pusch_td_res_idx].k2) {
+        // There is already a slice candidate for the same k2. Adding another candidate for the same k2 and different
+        // symbols would result in repeating the same slice candidates several times.
+        continue;
+      }
+
       const crb_bitmap pusch_used_crbs =
           pusch_alloc.ul_res_grid.used_crbs(cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.scs,
                                             cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs,
@@ -169,6 +176,7 @@ void inter_slice_scheduler::slot_indication(slot_point slot_tx, const cell_resou
         rb_lims = {pusch_rb_count, slice.inst.cfg.rbs.max()};
       }
       const auto prio = slice.get_prio(false, slot_tx, pusch_slot, rb_lims.stop());
+      allocated_k2.emplace(pusch_time_domain_list[pusch_td_res_idx].k2);
       ul_prio_queue.push(slice_candidate_context{slice.inst.id, prio, rb_lims, pusch_slot});
     }
   }
@@ -230,7 +238,7 @@ void inter_slice_scheduler::add_impl(ue& u)
   }
 }
 
-ue* inter_slice_scheduler::fetch_ue_to_update(du_ue_index_t ue_idx)
+ue* inter_slice_scheduler::fetch_ue_to_update(du_ue_index_t ue_idx) const
 {
   if (not ues.contains(ue_idx)) {
     // UE should be added to the repository at this stage.
@@ -410,8 +418,8 @@ inter_slice_scheduler::priority_type inter_slice_scheduler::ran_slice_sched_cont
   prio = (prio << delay_prio_bitsize) + delay_prio;
 
   // 5. Round-robin across slices with the same slice and delay priorities.
-  float               rbs_per_slot = is_dl ? inst.average_pdsch_rbs_per_slot() : inst.average_pusch_rbs_per_slot();
-  const priority_type rr_prio      = rr_bitmask - std::min((unsigned)std::round(rbs_per_slot), rr_bitmask);
+  const float         rbs_per_slot = is_dl ? inst.average_pdsch_rbs_per_slot() : inst.average_pusch_rbs_per_slot();
+  const priority_type rr_prio      = rr_bitmask - std::min(static_cast<unsigned>(std::round(rbs_per_slot)), rr_bitmask);
   prio                             = (prio << rr_bitsize) + rr_prio;
 
   // Add one bit to differentiate from skip priority.

lib/scheduler/slicing/inter_slice_scheduler.h

@@ -45,7 +45,7 @@ class inter_slice_scheduler
 
   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()].inst.cfg; }
-  scheduler_policy&              get_policy(ran_slice_id_t id) { return *slices[id.value()].policy; }
+  scheduler_policy&              get_policy(ran_slice_id_t id) const { return *slices[id.value()].policy; }
 
   void handle_slice_reconfiguration_request(const du_cell_slice_reconfig_request& slice_reconf_req);
 
@@ -131,7 +131,7 @@ class inter_slice_scheduler
   ran_slice_instance& get_slice(const logical_channel_config& lc_cfg);
 
   // Fetch UE if it is in a state to be added/reconfigured.
-  ue* fetch_ue_to_update(du_ue_index_t ue_idx);
+  ue* fetch_ue_to_update(du_ue_index_t ue_idx) const;
 
   void add_impl(ue& u);
 

lib/scheduler/ue_scheduling/grant_params_selector.cpp

@@ -338,7 +338,8 @@ static std::optional<ul_sched_context> get_ul_sched_context(const slice_ue&
                                                             slot_point                    pusch_slot,
                                                             unsigned                      uci_nof_harq_bits,
                                                             const ul_harq_process_handle* h_ul,
-                                                            unsigned                      pending_bytes)
+                                                            unsigned                      pending_bytes,
+                                                            ofdm_symbol_range             allowed_symbols)
 {
   const ue_cell& ue_cc = u.get_cc();
 
@@ -347,9 +348,10 @@ static std::optional<ul_sched_context> get_ul_sched_context(const slice_ue&
     return std::nullopt;
   }
 
-  const ue_cell_configuration& ue_cell_cfg      = ue_cc.cfg();
-  const cell_configuration&    cell_cfg         = ue_cell_cfg.cell_cfg_common;
-  unsigned                     slot_nof_symbols = cell_cfg.get_nof_ul_symbol_per_slot(pusch_slot);
+  const ue_cell_configuration& ue_cell_cfg = ue_cc.cfg();
+  const cell_configuration&    cell_cfg    = ue_cell_cfg.cell_cfg_common;
+  // If the slot has SRS allocated, take the min between the symbols per slots and available symbols in that slot.
+  unsigned slot_nof_symbols = std::min(cell_cfg.get_nof_ul_symbol_per_slot(pusch_slot), allowed_symbols.length());
 
   // TODO: Support more search spaces.
   static constexpr search_space_id ue_ded_ss_id = to_search_space_id(2);
@@ -380,7 +382,7 @@ static std::optional<ul_sched_context> get_ul_sched_context(const slice_ue&
   for (unsigned pusch_td_index = 0, e = ss.pusch_time_domain_list.size(); pusch_td_index != e; ++pusch_td_index) {
     const pusch_time_domain_resource_allocation& pusch_td_res = ss.pusch_time_domain_list[pusch_td_index];
 
-    // Check that k2 matches the chosen PUSCH slot
+    // Check that k2 matches the chosen PUSCH slot.
     if (pdcch_slot + pusch_td_res.k2 + cell_cfg.ntn_cs_koffset != pusch_slot) {
       continue;
     }
@@ -398,6 +400,12 @@ static std::optional<ul_sched_context> get_ul_sched_context(const slice_ue&
       continue;
     }
 
+    // Make sure the PUSCH time resource symbols fit within the UL symbols available in this slot; this is to avoid
+    // allocating the PUSCH over SRS resource symbols, if any.
+    if (not allowed_symbols.contains(pusch_td_res.symbols)) {
+      continue;
+    }
+
     // Compute recommended number of layers, MCS and PRBs.
     sch_mcs_index       mcs;
     pusch_config_params pusch_cfg;
@@ -452,22 +460,24 @@ static std::optional<ul_sched_context> get_ul_sched_context(const slice_ue&
   return std::nullopt;
 }
 
-std::optional<ul_sched_context> sched_helper::get_newtx_ul_sched_context(const slice_ue& u,
-                                                                         slot_point      pdcch_slot,
-                                                                         slot_point      pusch_slot,
-                                                                         unsigned        uci_nof_harq_bits,
-                                                                         unsigned        pending_bytes)
+std::optional<ul_sched_context> sched_helper::get_newtx_ul_sched_context(const slice_ue&   u,
+                                                                         slot_point        pdcch_slot,
+                                                                         slot_point        pusch_slot,
+                                                                         unsigned          uci_nof_harq_bits,
+                                                                         unsigned          pending_bytes,
+                                                                         ofdm_symbol_range allowed_symbols)
 {
-  return get_ul_sched_context(u, pdcch_slot, pusch_slot, uci_nof_harq_bits, nullptr, pending_bytes);
+  return get_ul_sched_context(u, pdcch_slot, pusch_slot, uci_nof_harq_bits, nullptr, pending_bytes, allowed_symbols);
 }
 
 std::optional<ul_sched_context> sched_helper::get_retx_ul_sched_context(const slice_ue&               u,
                                                                         slot_point                    pdcch_slot,
                                                                         slot_point                    pusch_slot,
                                                                         unsigned                      uci_nof_harq_bits,
-                                                                        const ul_harq_process_handle& h_ul)
+                                                                        const ul_harq_process_handle& h_ul,
+                                                                        ofdm_symbol_range             allowed_symbols)
 {
-  return get_ul_sched_context(u, pdcch_slot, pusch_slot, uci_nof_harq_bits, &h_ul, 0);
+  return get_ul_sched_context(u, pdcch_slot, pusch_slot, uci_nof_harq_bits, &h_ul, 0, allowed_symbols);
 }
 
 static vrb_interval

lib/scheduler/ue_scheduling/grant_params_selector.h

@@ -77,18 +77,20 @@ struct ul_sched_context {
 };
 
 /// Retrieve recommended PDCCH and PUSCH parameters for a newTx UL grant.
-std::optional<ul_sched_context> get_newtx_ul_sched_context(const slice_ue& u,
-                                                           slot_point      pdcch_slot,
-                                                           slot_point      pusch_slot,
-                                                           unsigned        uci_nof_harq_bits,
-                                                           unsigned        pending_bytes);
+std::optional<ul_sched_context> get_newtx_ul_sched_context(const slice_ue&   u,
+                                                           slot_point        pdcch_slot,
+                                                           slot_point        pusch_slot,
+                                                           unsigned          uci_nof_harq_bits,
+                                                           unsigned          pending_bytes,
+                                                           ofdm_symbol_range allowed_symbols);
 
 /// Retrieve recommended PDCCH and PUSCH parameters for a reTx UL grant.
 std::optional<ul_sched_context> get_retx_ul_sched_context(const slice_ue&               u,
                                                           slot_point                    pdcch_slot,
                                                           slot_point                    pusch_slot,
                                                           unsigned                      uci_nof_harq_bits,
-                                                          const ul_harq_process_handle& h_ul);
+                                                          const ul_harq_process_handle& h_ul,
+                                                          ofdm_symbol_range             allowed_symbols);
 
 /// Select UL VRBs to allocate for a newTx.
 vrb_interval compute_newtx_ul_vrbs(const ul_sched_context& decision_ctxt,

lib/scheduler/ue_scheduling/intra_slice_scheduler.cpp

@@ -147,7 +147,7 @@ intra_slice_scheduler::intra_slice_scheduler(const scheduler_ue_expert_config& e
   pending_ul_newtxs.reserve(MAX_UE_PDUS_PER_SLOT);
 
   // Pre-reserve memory for slice context.
-  const unsigned max_expected_ran_slices = 8;
+  constexpr unsigned max_expected_ran_slices = 8;
   slice_ctxt_list.reserve(max_expected_ran_slices);
 }
 
@@ -201,6 +201,7 @@ void intra_slice_scheduler::ul_sched(ul_ran_slice_candidate slice, scheduler_pol
 
   if (slice.get_slot_tx() != pusch_slot) {
     pusch_slot = slice.get_slot_tx();
+    update_min_srs_symbol();
     update_used_ul_vrbs(slice);
   }
 
@@ -243,7 +244,7 @@ static std::pair<unsigned, unsigned> get_max_grants_and_rb_grant_size(span<const
     return std::make_pair(0, 0);
   }
 
-  // Determine how many UE grants to allocate in the slot (assuming full buffer). As an heuristic, we divide the number
+  // Determine how many UE grants to allocate in the slot (assuming full buffer). As a heuristic, we divide the number
   // of candidates by 4 and set 8 as the maximum number of UEs to be scheduled per slot, assuming full buffer. This
   // heuristic is a result of a tradeoff between minimizing latency and ensuring we don't deplete the PDCCH resources.
   static constexpr unsigned MAX_UE_GRANT_PER_SLOT = 8;
@@ -351,7 +352,10 @@ unsigned intra_slice_scheduler::schedule_ul_retx_candidates(ul_ran_slice_candida
     }
 
     // Allocate PDCCH and PUSCH.
-    auto result = ue_alloc.allocate_ul_grant(ue_retx_ul_grant_request{u, pusch_slot, h, used_ul_vrbs});
+    // NOTE: the symbols passed to the grant are the symbols that are available for PUSCH and for which the used VRBs
+    // have been computed.
+    auto result = ue_alloc.allocate_ul_grant(
+        ue_retx_ul_grant_request{u, pusch_slot, h, used_ul_vrbs, ofdm_symbol_range{0, min_srs_symbol}});
     if (not result.has_value() and result.error() == alloc_status::skip_slot) {
       // Received signal to stop allocations in the slot.
       break;
@@ -456,7 +460,7 @@ unsigned intra_slice_scheduler::schedule_dl_newtx_candidates(dl_ran_slice_candid
   for (const auto& ue_candidate : newtx_candidates) {
     if (pucch_grant_limit_exceeded) {
       // The PUCCH is likely saturated and there is no space for new PUCCHs.
-      // As an heuristic, we only allocate DL grants to UEs which already have a PUCCH or a PUSCH in a future slot that
+      // As a heuristic, we only allocate DL grants to UEs which already have a PUCCH or a PUSCH in a future slot that
       // can likely accommodate more HARQ-ACK bits.
       if (not(ue_candidate.ue_cc->harqs.last_ack_slot().valid() and
               ue_candidate.ue_cc->harqs.last_ack_slot() > pdsch_slot) and
@@ -586,8 +590,10 @@ unsigned intra_slice_scheduler::schedule_ul_newtx_candidates(ul_ran_slice_candid
   unsigned rb_count = 0;
   for (const auto& ue_candidate : newtx_candidates) {
     // Create UL grant builder.
-    auto result =
-        ue_alloc.allocate_ul_grant(ue_newtx_ul_grant_request{*ue_candidate.ue, pusch_slot, ue_candidate.pending_bytes});
+    // NOTE: the symbols passed to the grant are the symbols that are available for PUSCH and for which the used VRBs
+    // have been computed.
+    auto result = ue_alloc.allocate_ul_grant(ue_newtx_ul_grant_request{
+        *ue_candidate.ue, pusch_slot, ue_candidate.pending_bytes, ofdm_symbol_range{0, min_srs_symbol}});
 
     if (result.has_value()) {
       // Allocation was successful. Move grant builder to list of pending newTx grants.
@@ -656,7 +662,7 @@ unsigned intra_slice_scheduler::schedule_ul_newtx_candidates(ul_ran_slice_candid
     // Update slice state.
     slice.store_grant(nof_rbs_alloc);
     rb_count += nof_rbs_alloc;
-    rbs_missing = (max_grant_size - nof_rbs_alloc);
+    rbs_missing = max_grant_size - nof_rbs_alloc;
   }
 
   // Clear grant builders.
@@ -747,7 +753,7 @@ std::optional<ue_newtx_candidate> intra_slice_scheduler::create_newtx_ul_candida
   return ue_newtx_candidate{&u, &ue_cc, pending_bytes, forbid_sched_priority};
 }
 
-unsigned intra_slice_scheduler::max_pdschs_to_alloc(const dl_ran_slice_candidate& slice)
+unsigned intra_slice_scheduler::max_pdschs_to_alloc(const dl_ran_slice_candidate& slice) const
 {
   // We cannot allocate more than the number of UEs available.
   int pdschs_to_alloc = slice.get_slice_ues().size();
@@ -784,7 +790,7 @@ unsigned intra_slice_scheduler::max_pdschs_to_alloc(const dl_ran_slice_candidate
   return std::max(pdschs_to_alloc, 0);
 }
 
-unsigned intra_slice_scheduler::max_puschs_to_alloc(const ul_ran_slice_candidate& slice)
+unsigned intra_slice_scheduler::max_puschs_to_alloc(const ul_ran_slice_candidate& slice) const
 {
   if (not cell_alloc.cfg.is_ul_enabled(slice.get_slot_tx())) {
     return 0;
@@ -882,10 +888,40 @@ void intra_slice_scheduler::update_used_ul_vrbs(const ul_ran_slice_candidate& sl
 
   // (Implementation-defined) We use the common PUSCH TD resources as a reference for the computation of RBs unavailable
   // for PDSCH. This assumes that these resources are not colliding with SRS.
-  const auto&              init_ul_bwp      = cell_alloc.cfg.ul_cfg_common.init_ul_bwp;
-  const ofdm_symbol_range& symbols_to_check = init_ul_bwp.pusch_cfg_common->pusch_td_alloc_list[0].symbols;
+  const auto& init_ul_bwp = cell_alloc.cfg.ul_cfg_common.init_ul_bwp;
+  srsran_assert(slice.get_slot_tx() - cell_alloc[0].slot > 0, "PUSCH slot cannot precede its corresponding PDCCH slot");
+  const unsigned    slice_candidate_k2 = slice.get_slot_tx() - cell_alloc[0].slot;
+  ofdm_symbol_range symbols_to_check   = {0, 0};
+  // Find the max symbols such that symbols.stop() <= min_srs_symbol;
+  for (auto& td_res : init_ul_bwp.pusch_cfg_common->pusch_td_alloc_list) {
+    // We can choose only the symbols for the same k2.
+    if (td_res.k2 < slice_candidate_k2) {
+      continue;
+    }
+    if (td_res.k2 == slice_candidate_k2) {
+      if (td_res.symbols.stop() <= min_srs_symbol and td_res.symbols.stop() > symbols_to_check.stop())
+        symbols_to_check = td_res.symbols;
+    }
+    if (td_res.k2 > slice_candidate_k2) {
+      break;
+    }
+  }
+
+  if (symbols_to_check.empty()) {
+    logger.debug(
+        "No symbols available for PUSCH allocation on slot={} for slice_id={}", pusch_slot, slice.id().value());
+  }
 
   used_ul_vrbs = cell_alloc[pusch_slot]
                      .ul_res_grid.used_prbs(init_ul_bwp.generic_params.scs, ul_crb_lims, symbols_to_check)
                      .convert_to<vrb_bitmap>();
 }
+
+void intra_slice_scheduler::update_min_srs_symbol()
+{
+  // Reset to max symbol index before looking for the min.
+  min_srs_symbol = NOF_OFDM_SYM_PER_SLOT_NORMAL_CP;
+  for (const auto& srs : cell_alloc[pusch_slot - pdcch_slot].result.ul.srss) {
+    min_srs_symbol = std::min(static_cast<unsigned>(srs.symbols.start()), min_srs_symbol);
+  }
+}

lib/scheduler/ue_scheduling/intra_slice_scheduler.h

@@ -100,14 +100,16 @@ class intra_slice_scheduler
                                         scheduler_policy&       ul_policy,
                                         unsigned                max_ue_grants_to_alloc);
 
-  unsigned max_pdschs_to_alloc(const dl_ran_slice_candidate& slice);
+  unsigned max_pdschs_to_alloc(const dl_ran_slice_candidate& slice) const;
 
-  unsigned max_puschs_to_alloc(const ul_ran_slice_candidate& slice);
+  unsigned max_puschs_to_alloc(const ul_ran_slice_candidate& slice) const;
 
   // Called when bitmap of used VRBs needs to be recalculated.
   void update_used_dl_vrbs(const dl_ran_slice_candidate& slice);
   void update_used_ul_vrbs(const ul_ran_slice_candidate& slice);
 
+  void update_min_srs_symbol();
+
   const scheduler_ue_expert_config& expert_cfg;
   const cell_resource_allocator&    cell_alloc;
   cell_metrics_handler&             cell_metrics;
@@ -140,6 +142,8 @@ class intra_slice_scheduler
   vrb_bitmap used_dl_vrbs;
   bool       enable_pdsch_interleaving = false;
   vrb_bitmap used_ul_vrbs;
+  // Minimum symbol index used for SRS resources within this slot.
+  unsigned min_srs_symbol = 0;
 
   // Grants being built for the current slice.
   std::vector<ue_cell_grid_allocator::dl_newtx_grant_builder> pending_dl_newtxs;