sched: fix failing unittests and remove verbose logs

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

Author: carlo-gal

lib/scheduler/ue_scheduling/ue_fallback_scheduler.cpp

@@ -46,6 +46,9 @@ void ue_fallback_scheduler::run_slot(cell_resource_allocator& res_alloc)
   // retransmitted.
   update_ongoing_ue_retxs();
 
+  // Reset the scheduling attempt counter; this takes into account retxs and new txs.
+  sched_attempts_cnt = 0;
+
   if (ues.empty()) {
     return;
   }
@@ -109,7 +112,6 @@ void ue_fallback_scheduler::run_slot(cell_resource_allocator& res_alloc)
     if (u.has_pending_dl_newtx_bytes(LCID_SRB1) and schedule_srb(res_alloc, u, false, nullptr, most_recent_tx_ack)) {
       // If all bytes of SRB1 are scheduled, remove UE.
       if (not u.has_pending_dl_newtx_bytes(LCID_SRB1)) {
-        logger.debug("rnti={}: Removing UE from list, as SRB1 buffer is empty.", u.crnti);
         next_ue = pending_ues.erase(next_ue);
       }
       // Don't increase the iterator here, as we give priority to the same UE, if there are still some SRB1 bytes left
@@ -167,9 +169,6 @@ bool ue_fallback_scheduler::schedule_srb(cell_resource_allocator&       res_allo
     return false;
   }
 
-  // We keep track of the number of scheduling attempts for the given UE.
-  unsigned sched_attempts_cnt = 0;
-
   // \ref starting_slot is the slot from which the SRB0 starts scheduling this given UE. Assuming the UE was assigned a
   // PDSCH grant for SRB1 that was fragmented, we want to avoid allocating the second part of SRB1 in a PDSCH that is
   // scheduled for an earlier slot than the PDSCH of the first part of the SRB1.
@@ -187,7 +186,7 @@ bool ue_fallback_scheduler::schedule_srb(cell_resource_allocator&       res_allo
 
     for (unsigned time_res_idx = 0; time_res_idx != bwp_cfg_common.pdsch_common.pdsch_td_alloc_list.size();
          ++time_res_idx) {
-      if (sched_attempts_cnt >= max_sched_attempts_per_ue) {
+      if (sched_attempts_cnt >= max_sched_attempts) {
         return false;
       }
 
@@ -221,7 +220,7 @@ bool ue_fallback_scheduler::schedule_srb(cell_resource_allocator&       res_allo
 
       // Verify there is space in PDSCH and PDCCH result lists for new allocations.
       if (pdcch_alloc.result.dl.dl_pdcchs.full() or pdsch_alloc.result.dl.ue_grants.full()) {
-        logger.debug("rnti={}: Failed to allocate PDSCH for {}. Cause: No space available in scheduler output list.",
+        logger.debug("rnti={}: Failed to allocate PDSCH for {}. Cause: No space available in scheduler output list",
                      u.crnti,
                      is_srb0 ? "SRB0" : "SRB1");
         return false;
@@ -248,8 +247,6 @@ bool ue_fallback_scheduler::schedule_srb(cell_resource_allocator&       res_allo
         if (not is_retx) {
           store_harq_tx(u.ue_index, candidate_h_dl, is_srb0);
         }
-        logger.debug(
-            "rnti={}: PDSCH space for SRB{} scheduled for slot:{}", u.crnti, is_srb0 ? "0" : "1", pdsch_alloc.slot);
         return true;
       }
 
@@ -259,11 +256,11 @@ bool ue_fallback_scheduler::schedule_srb(cell_resource_allocator&       res_allo
 
   // No resource found in UE's carriers and Search spaces.
   slot_point pdcch_slot = res_alloc[0].slot;
-  logger.debug("rnti={}: Not enough PDSCH space for {} message found in any of the slots:[{},{})",
+  logger.debug("rnti={}: Not enough PDCCH/PDSCH/PUCCH resources for {} message found in any of the slots:[{},{})",
                u.crnti,
                is_srb0 ? "SRB0" : "SRB1",
                pdcch_slot,
-               pdcch_slot + max_dl_slots_ahead_sched);
+               pdcch_slot + max_dl_slots_ahead_sched + 1);
   return false;
 }
 

lib/scheduler/ue_scheduling/ue_fallback_scheduler.h

@@ -129,10 +129,13 @@ class ue_fallback_scheduler
   // Set the max number of slots the scheduler can look ahead in the resource grid (with respect to the current slot) to
   // find PDSCH space for SRB0 or SRB1.
   const unsigned max_dl_slots_ahead_sched = 10U;
-  // Set the max number of attempt the scheduler can do while running through the nested loops over the PDSCH time
-  // allocation indices and the ahead slots. This is to avoid excessive long iterations in case of a large number of
-  // PDSCH time allocation indices.
-  const unsigned            max_sched_attempts_per_ue = 10U;
+  // Set the max number of attempts the scheduler can do while running through the nested loops over the PDSCH time
+  // allocation indices and the ahead slots for all UEs. This is to avoid excessive long iterations in case many UEs.
+  // NOTE: max_sched_attempts = (max_dl_slots_ahead_sched + 1) * max_pdsch_time_res guarantees that at 1 UE will be
+  // allocated in a TDD period of 10 slots.
+  const unsigned max_sched_attempts = 22U;
+  // Counter for the scheduling attempts per function call.
+  unsigned                  sched_attempts_cnt = 0;
   pdcch_resource_allocator& pdcch_sch;
   pucch_allocator&          pucch_alloc;
   ue_repository&            ues;

tests/unittests/scheduler/ue_scheduling/fallback_scheduler_test.cpp

@@ -180,7 +180,7 @@ class base_fallback_tester
     bench->pucch_alloc.slot_indication(current_slot);
   }
 
-  void run_slot(bool disabled_csi_rs = false)
+  void run_slot()
   {
     ++current_slot;
 
@@ -192,9 +192,7 @@ class base_fallback_tester
     bench->pdcch_sch.slot_indication(current_slot);
     bench->pucch_alloc.slot_indication(current_slot);
 
-    if (not disabled_csi_rs) {
-      bench->csi_rs_sched.run_slot(bench->res_grid[0]);
-    }
+    bench->csi_rs_sched.run_slot(bench->res_grid[0]);
 
     bench->fallback_sched.run_slot(bench->res_grid);
 
@@ -318,18 +316,19 @@ TEST_P(fallback_scheduler_tester, successfully_allocated_resources)
 {
   setup_sched(create_expert_config(2), create_custom_cell_config_request(params.k0));
   // Add UE.
-  add_ue(to_rnti(0x4601), to_du_ue_index(0));
+  const du_ue_index_t ue_idx = to_du_ue_index(0);
+  add_ue(to_rnti(0x4601), ue_idx);
   // Notify about SRB0 message in DL of size 101 bytes.
   const unsigned mac_srb0_sdu_size = 101;
-  push_buffer_state_to_dl_ue(to_du_ue_index(0), mac_srb0_sdu_size);
+  push_buffer_state_to_dl_ue(ue_idx, mac_srb0_sdu_size);
 
-  const unsigned exp_size = get_pending_bytes(to_du_ue_index(0));
+  const unsigned exp_size = get_pending_bytes(ue_idx);
 
   // Test the following:
   // 1. Check for DCI_1_0 allocation for SRB0 on PDCCH.
   // 2. Check for PDSCH allocation.
   // 3. Check whether CW TB bytes matches with pending bytes to be sent.
-  const auto& test_ue = get_ue(to_du_ue_index(0));
+  const auto& test_ue = get_ue(ue_idx);
   bool        is_ue_allocated_pdcch{false};
   bool        is_ue_allocated_pdsch{false};
   for (unsigned sl_idx = 0; sl_idx < bench->max_test_run_slots_per_ue * (1U << current_slot.numerology()); sl_idx++) {
@@ -344,6 +343,7 @@ TEST_P(fallback_scheduler_tester, successfully_allocated_resources)
   }
   ASSERT_TRUE(is_ue_allocated_pdcch);
   ASSERT_TRUE(is_ue_allocated_pdsch);
+  ASSERT_FALSE(test_ue.has_pending_dl_newtx_bytes(LCID_SRB0));
 }
 
 TEST_P(fallback_scheduler_tester, failed_allocating_resources)
@@ -377,14 +377,15 @@ TEST_P(fallback_scheduler_tester, test_large_srb0_buffer_size)
 {
   setup_sched(create_expert_config(27), create_custom_cell_config_request(params.k0));
   // Add UE.
-  add_ue(to_rnti(0x4601), to_du_ue_index(0));
+  const du_ue_index_t ue_idx = to_du_ue_index(0);
+  add_ue(to_rnti(0x4601), ue_idx);
   // Notify about SRB0 message in DL of size 458 bytes.
   const unsigned mac_srb0_sdu_size = 458;
-  push_buffer_state_to_dl_ue(to_du_ue_index(0), mac_srb0_sdu_size);
+  push_buffer_state_to_dl_ue(ue_idx, mac_srb0_sdu_size);
 
-  const unsigned exp_size = get_pending_bytes(to_du_ue_index(0));
+  const unsigned exp_size = get_pending_bytes(ue_idx);
 
-  const auto& test_ue = get_ue(to_du_ue_index(0));
+  const auto& test_ue = get_ue(ue_idx);
   bool        is_ue_allocated_pdcch{false};
   bool        is_ue_allocated_pdsch{false};
   for (unsigned sl_idx = 0; sl_idx < bench->max_test_run_slots_per_ue * (1U << current_slot.numerology()); sl_idx++) {
@@ -399,6 +400,8 @@ TEST_P(fallback_scheduler_tester, test_large_srb0_buffer_size)
   }
   ASSERT_TRUE(is_ue_allocated_pdcch);
   ASSERT_TRUE(is_ue_allocated_pdsch);
+
+  ASSERT_FALSE(test_ue.has_pending_dl_newtx_bytes(LCID_SRB0));
 }
 
 TEST_P(fallback_scheduler_tester, test_srb0_buffer_size_exceeding_max_msg4_mcs_index)
@@ -424,7 +427,8 @@ TEST_P(fallback_scheduler_tester, sanity_check_with_random_max_mcs_and_payload_s
   const sch_mcs_index max_msg4_mcs = get_random_uint(0, 27);
   setup_sched(create_expert_config(max_msg4_mcs), create_custom_cell_config_request(params.k0));
   // Add UE.
-  add_ue(to_rnti(0x4601), to_du_ue_index(0));
+  const du_ue_index_t ue_idx = to_du_ue_index(0);
+  add_ue(to_rnti(0x4601), ue_idx);
   // Random payload size.
   const unsigned mac_srb0_sdu_size = get_random_uint(1, 458);
   push_buffer_state_to_dl_ue(to_du_ue_index(0), mac_srb0_sdu_size);
@@ -444,7 +448,7 @@ class fallback_scheduler_tdd_tester : public base_fallback_tester, public ::test
 TEST_F(fallback_scheduler_tdd_tester, test_allocation_in_appropriate_slots_in_tdd)
 {
   const unsigned      k0                 = 0;
-  const sch_mcs_index max_msg4_mcs_index = 1;
+  const sch_mcs_index max_msg4_mcs_index = 5;
   auto                cell_cfg           = create_custom_cell_config_request(k0);
   setup_sched(create_expert_config(max_msg4_mcs_index), cell_cfg);
 
@@ -477,6 +481,11 @@ TEST_F(fallback_scheduler_tdd_tester, test_allocation_in_appropriate_slots_in_td
       }
     }
   }
+
+  for (unsigned ue_idx = 0; ue_idx < MAX_UES; ue_idx++) {
+    const auto& test_ue = get_ue(to_du_ue_index(ue_idx));
+    ASSERT_FALSE(test_ue.has_pending_dl_newtx_bytes(LCID_SRB0)) << "UE " << ue_idx << " has still pending DL bytes";
+  }
 }
 
 TEST_F(fallback_scheduler_tdd_tester, test_allocation_in_partial_slots_tdd)
@@ -493,6 +502,9 @@ TEST_F(fallback_scheduler_tdd_tester, test_allocation_in_partial_slots_tdd)
   // Generate PDSCH Time domain allocation based on the partial slot TDD configuration.
   cell_cfg.dl_cfg_common.init_dl_bwp.pdsch_common.pdsch_td_alloc_list = config_helpers::make_pdsch_time_domain_resource(
       cell_cfg.searchspace0, cell_cfg.dl_cfg_common.init_dl_bwp.pdcch_common, nullopt, cell_cfg.tdd_ul_dl_cfg_common);
+  // Disabled CSI-RS resources, as this test uses a TDD configuration that is not compatible with CSI-RS scheduling.
+  cell_cfg.nzp_csi_rs_res_list.clear();
+  cell_cfg.zp_csi_rs_list.clear();
   setup_sched(create_expert_config(max_msg4_mcs_index), cell_cfg);
 
   const unsigned MAX_TEST_RUN_SLOTS = 40;
@@ -502,7 +514,7 @@ TEST_F(fallback_scheduler_tdd_tester, test_allocation_in_partial_slots_tdd)
   add_ue(to_rnti(0x4601), to_du_ue_index(0));
 
   for (unsigned idx = 0; idx < MAX_TEST_RUN_SLOTS * (1U << current_slot.numerology()); idx++) {
-    run_slot(true);
+    run_slot();
     // Notify about SRB0 message in DL one slot before partial slot in order for it to be scheduled in the next
     // (partial) slot.
     if (bench->cell_cfg.is_dl_enabled(current_slot + 1) and