sched: refactor passing of slot at which PUSCH needs to be allocated

Author: herlesupreeth

lib/scheduler/policy/scheduler_time_pf.cpp

@@ -94,7 +94,7 @@ void scheduler_time_pf::ul_sched(ue_pusch_allocator&          pusch_alloc,
   while (not ul_queue.empty() and rem_rbs > 0) {
     ue_ctxt& ue = *ul_queue.top();
     if (alloc_result.status != alloc_status::skip_slot) {
-      alloc_result = try_ul_alloc(ue, ues, pusch_alloc, rem_rbs, slice_candidate.get_slot_tx());
+      alloc_result = try_ul_alloc(ue, ues, pusch_alloc, rem_rbs);
     }
     ue.save_ul_alloc(alloc_result.alloc_bytes);
     // Re-add the UE to the queue if scheduling of re-transmission fails so that scheduling of retransmission are
@@ -143,12 +143,10 @@ alloc_result scheduler_time_pf::try_dl_alloc(ue_ctxt&                   ctxt,
 alloc_result scheduler_time_pf::try_ul_alloc(ue_ctxt&                   ctxt,
                                              const slice_ue_repository& ues,
                                              ue_pusch_allocator&        pusch_alloc,
-                                             unsigned                   max_rbs,
-                                             slot_point                 pusch_slot)
+                                             unsigned                   max_rbs)
 {
   alloc_result   alloc_result = {alloc_status::invalid_params};
   ue_pusch_grant grant{&ues[ctxt.ue_index], ctxt.cell_index};
-  grant.pusch_slot = pusch_slot;
   // Prioritize reTx over newTx.
   if (ctxt.ul_retx_h != nullptr) {
     grant.h_id   = ctxt.ul_retx_h->id;

lib/scheduler/policy/scheduler_time_pf.h

@@ -83,11 +83,8 @@ class scheduler_time_pf : public scheduler_policy
   try_dl_alloc(ue_ctxt& ctxt, const slice_ue_repository& ues, ue_pdsch_allocator& pdsch_alloc, unsigned max_rbs);
   /// \brief Attempts to allocate PUSCH for a UE.
   /// \return Returns allocation status, nof. allocated bytes and nof. allocated RBs.
-  alloc_result try_ul_alloc(ue_ctxt&                   ctxt,
-                            const slice_ue_repository& ues,
-                            ue_pusch_allocator&        pusch_alloc,
-                            unsigned                   max_rbs,
-                            slot_point                 pusch_slot);
+  alloc_result
+  try_ul_alloc(ue_ctxt& ctxt, const slice_ue_repository& ues, ue_pusch_allocator& pusch_alloc, unsigned max_rbs);
 
   slotted_id_table<du_ue_index_t, ue_ctxt, MAX_NOF_DU_UES> ue_history_db;
 

lib/scheduler/policy/scheduler_time_rr.cpp

@@ -329,7 +329,6 @@ static alloc_result alloc_ul_ue(const slice_ue&         u,
                                 bool                    schedule_sr_only,
                                 srslog::basic_logger&   logger,
                                 ran_slice_id_t          slice_id,
-                                slot_point              pusch_slot,
                                 std::optional<unsigned> ul_new_tx_max_nof_rbs_per_ue_per_slot = {})
 {
   unsigned pending_newtx_bytes = 0;
@@ -359,7 +358,7 @@ static alloc_result alloc_ul_ue(const slice_ue&         u,
 
     // Iterate through allocation parameter candidates.
     for (const ul_harq_process* h_ul : harq_candidates) {
-      ue_pusch_grant grant{&u, ue_cc.cell_index, h_ul->id, pusch_slot};
+      ue_pusch_grant grant{&u, ue_cc.cell_index, h_ul->id};
       if (not is_retx) {
         grant.recommended_nof_bytes = pending_newtx_bytes;
         grant.max_nof_rbs           = ul_new_tx_max_nof_rbs_per_ue_per_slot;
@@ -424,10 +423,9 @@ void scheduler_time_rr::ul_sched(ue_pusch_allocator&          pusch_alloc,
                                  const ue_resource_grid_view& res_grid,
                                  ul_ran_slice_candidate&      slice_candidate)
 {
-  const slice_ue_repository& ues        = slice_candidate.get_slice_ues();
-  const unsigned             max_rbs    = slice_candidate.remaining_rbs();
-  const ran_slice_id_t       slice_id   = slice_candidate.id();
-  const slot_point           pusch_slot = slice_candidate.get_slot_tx();
+  const slice_ue_repository& ues      = slice_candidate.get_slice_ues();
+  const unsigned             max_rbs  = slice_candidate.remaining_rbs();
+  const ran_slice_id_t       slice_id = slice_candidate.id();
 
   if (ues.empty() or max_rbs == 0) {
     // No UEs to be scheduled or if there are no RBs to be scheduled in slice.
@@ -438,20 +436,18 @@ void scheduler_time_rr::ul_sched(ue_pusch_allocator&          pusch_alloc,
   const unsigned ul_new_tx_max_nof_rbs_per_ue_per_slot =
       compute_max_nof_rbs_per_ue_per_slot(ues, false, res_grid, expert_cfg, max_rbs);
   // First, schedule UEs with pending SR.
-  auto sr_ue_function =
-      [this, &pusch_alloc, ul_new_tx_max_nof_rbs_per_ue_per_slot, slice_id, pusch_slot](const slice_ue& u) {
-        return alloc_ul_ue(
-            u, pusch_alloc, false, true, logger, slice_id, pusch_slot, ul_new_tx_max_nof_rbs_per_ue_per_slot);
-      };
+  auto sr_ue_function = [this, &pusch_alloc, ul_new_tx_max_nof_rbs_per_ue_per_slot, slice_id](const slice_ue& u) {
+    return alloc_ul_ue(u, pusch_alloc, false, true, logger, slice_id, ul_new_tx_max_nof_rbs_per_ue_per_slot);
+  };
   auto result      = round_robin_apply(ues, next_ul_ue_index, sr_ue_function);
   next_ul_ue_index = result.first;
   if (result.second == alloc_status::skip_slot) {
     return;
   }
 
   // Second, schedule UEs with re-transmissions.
-  auto data_retx_ue_function = [this, &pusch_alloc, slice_id, pusch_slot](const slice_ue& u) {
-    return alloc_ul_ue(u, pusch_alloc, true, false, logger, slice_id, pusch_slot);
+  auto data_retx_ue_function = [this, &pusch_alloc, slice_id](const slice_ue& u) {
+    return alloc_ul_ue(u, pusch_alloc, true, false, logger, slice_id);
   };
   result           = round_robin_apply(ues, next_ul_ue_index, data_retx_ue_function);
   next_ul_ue_index = result.first;
@@ -462,9 +458,8 @@ void scheduler_time_rr::ul_sched(ue_pusch_allocator&          pusch_alloc,
   // Then, schedule UEs with new transmissions.
   if (ul_new_tx_max_nof_rbs_per_ue_per_slot > 0) {
     auto data_tx_ue_function =
-        [this, &pusch_alloc, ul_new_tx_max_nof_rbs_per_ue_per_slot, slice_id, pusch_slot](const slice_ue& u) {
-          return alloc_ul_ue(
-              u, pusch_alloc, false, false, logger, slice_id, pusch_slot, ul_new_tx_max_nof_rbs_per_ue_per_slot);
+        [this, &pusch_alloc, ul_new_tx_max_nof_rbs_per_ue_per_slot, slice_id](const slice_ue& u) {
+          return alloc_ul_ue(u, pusch_alloc, false, false, logger, slice_id, ul_new_tx_max_nof_rbs_per_ue_per_slot);
         };
     result           = round_robin_apply(ues, next_ul_ue_index, data_tx_ue_function);
     next_ul_ue_index = result.first;

lib/scheduler/policy/ue_allocator.h

@@ -35,8 +35,6 @@ struct ue_pusch_grant {
   const slice_ue* user;
   du_cell_index_t cell_index;
   harq_id_t       h_id;
-  /// Slot at which PUSCH grant needs to be allocated.
-  slot_point pusch_slot;
   /// Recommended nof. bytes to schedule. This field is not present/ignored in case of HARQ retransmission.
   std::optional<unsigned> recommended_nof_bytes;
   /// Maximum nof. RBs to allocate to the UE. This field is not present/ignored in case of HARQ retransmission.

lib/scheduler/ue_scheduling/ue_cell_grid_allocator.cpp

@@ -483,7 +483,8 @@ alloc_result ue_cell_grid_allocator::allocate_dl_grant(const ue_pdsch_grant& gra
   return {alloc_status::invalid_params};
 }
 
-alloc_result ue_cell_grid_allocator::allocate_ul_grant(const ue_pusch_grant& grant, ran_slice_id_t slice_id)
+alloc_result
+ue_cell_grid_allocator::allocate_ul_grant(const ue_pusch_grant& grant, ran_slice_id_t slice_id, slot_point pusch_slot)
 {
   srsran_assert(ues.contains(grant.user->ue_index()), "Invalid UE candidate index={}", grant.user->ue_index());
   srsran_assert(has_cell(grant.cell_index), "Invalid UE candidate cell_index={}", grant.cell_index);
@@ -554,8 +555,6 @@ alloc_result ue_cell_grid_allocator::allocate_ul_grant(const ue_pusch_grant& gra
     return {alloc_status::invalid_params};
   }
 
-  slot_point pusch_slot = grant.pusch_slot;
-
   // Create PUSCH param candidate search object.
   ue_pusch_alloc_param_candidate_searcher candidates{
       u, grant.cell_index, h_ul, pdcch_alloc.slot, slots_with_no_pusch_space, pusch_slot};

lib/scheduler/ue_scheduling/ue_cell_grid_allocator.h

@@ -40,7 +40,7 @@ class ue_cell_grid_allocator
 
   alloc_result allocate_dl_grant(const ue_pdsch_grant& grant, ran_slice_id_t slice_id);
 
-  alloc_result allocate_ul_grant(const ue_pusch_grant& grant, ran_slice_id_t slice_id);
+  alloc_result allocate_ul_grant(const ue_pusch_grant& grant, ran_slice_id_t slice_id, slot_point pusch_slot);
 
 private:
   struct cell_t {
@@ -114,7 +114,8 @@ class ul_slice_ue_cell_grid_allocator : public ue_pusch_allocator
 
   alloc_result allocate_ul_grant(const ue_pusch_grant& grant) override
   {
-    const alloc_result result = pusch_alloc.allocate_ul_grant(grant, slice_candidate.id());
+    const alloc_result result =
+        pusch_alloc.allocate_ul_grant(grant, slice_candidate.id(), slice_candidate.get_slot_tx());
     if (result.status == alloc_status::success) {
       slice_candidate.store_grant(result.alloc_nof_rbs);
     }