sched: add option to automatically forward UCI/CRC indications to scheduler in tests

Author: frankist

tests/unittests/scheduler/scheduler_tdd_test.cpp

@@ -31,7 +31,9 @@ struct tdd_test_params {
 class base_scheduler_tdd_tester : public scheduler_test_simulator
 {
 protected:
-  base_scheduler_tdd_tester(const tdd_test_params& testparams) : scheduler_test_simulator(4, testparams.tdd_cfg.ref_scs)
+  base_scheduler_tdd_tester(const tdd_test_params& testparams) :
+    scheduler_test_simulator(
+        scheduler_test_sim_config{.max_scs = testparams.tdd_cfg.ref_scs, .auto_uci = true, .auto_crc = true})
   {
     params                      = cell_config_builder_profiles::tdd(testparams.tdd_cfg.ref_scs);
     params.csi_rs_enabled       = testparams.csi_rs_enabled;
@@ -100,16 +102,6 @@ TEST_P(scheduler_dl_tdd_tester, all_dl_slots_are_scheduled)
       ASSERT_FALSE(this->last_sched_res_list[to_du_cell_index(0)]->dl.ue_grants.empty()) << fmt::format(
           "The UE configuration is leading to slot {} not having DL UE grant scheduled", this->last_result_slot());
     }
-
-    for (const pucch_info& pucch : this->last_sched_res_list[to_du_cell_index(0)]->ul.pucchs) {
-      if (pucch.format() == pucch_format::FORMAT_1 and pucch.uci_bits.sr_bits != sr_nof_bits::no_sr) {
-        // Skip SRs for this test.
-        continue;
-      }
-
-      uci_indication uci_ind = test_helper::create_uci_indication(this->last_result_slot(), ue_idx, pucch);
-      this->sched->handle_uci_indication(uci_ind);
-    }
   }
 }
 
@@ -127,19 +119,6 @@ class scheduler_ul_tdd_tester : public base_scheduler_tdd_tester, public ::testi
     unsigned tdd_period = nof_slots_per_tdd_period(*cell_cfg_list[0].tdd_cfg_common);
     for (unsigned i = 0; i != 2 * tdd_period; ++i) {
       run_slot();
-
-      for (const ul_sched_info& pusch : this->last_sched_res_list[to_du_cell_index(0)]->ul.puschs) {
-        ul_crc_indication crc{};
-        crc.cell_index = to_du_cell_index(0);
-        crc.sl_rx      = this->last_result_slot();
-        crc.crcs.resize(1);
-        crc.crcs[0].ue_index       = ue_idx;
-        crc.crcs[0].rnti           = ue_rnti;
-        crc.crcs[0].harq_id        = to_harq_id(pusch.pusch_cfg.harq_id);
-        crc.crcs[0].tb_crc_success = true;
-        crc.crcs[0].ul_sinr_dB     = 100.0F;
-        this->sched->handle_crc_indication(crc);
-      }
     }
   }
 };

tests/unittests/scheduler/test_utils/scheduler_test_simulator.cpp

@@ -9,6 +9,7 @@
  */
 
 #include "scheduler_test_simulator.h"
+#include "../test_utils/indication_generators.h"
 #include "config_generators.h"
 #include "sched_random_utils.h"
 #include "scheduler_test_suite.h"
@@ -50,6 +51,13 @@ scheduler_test_simulator::scheduler_test_simulator(unsigned           tx_rx_dela
 {
 }
 
+scheduler_test_simulator::scheduler_test_simulator(const scheduler_test_sim_config& cfg) :
+  scheduler_test_simulator(cfg.sched_cfg, cfg.tx_rx_delay, cfg.max_scs)
+{
+  auto_uci = cfg.auto_uci;
+  auto_crc = cfg.auto_crc;
+}
+
 scheduler_test_simulator::~scheduler_test_simulator()
 {
   // Let any pending allocations complete.
@@ -79,11 +87,18 @@ void scheduler_test_simulator::add_ue(const sched_ue_creation_request_message& u
       run_slot();
     }
   }
+  rnti_to_ue_index.insert(std::make_pair(ue_request.crnti, ue_request.ue_index));
 }
 
 void scheduler_test_simulator::rem_ue(du_ue_index_t ue_index)
 {
   sched->handle_ue_removal_request(ue_index);
+  for (auto it = rnti_to_ue_index.begin(); it != rnti_to_ue_index.end(); ++it) {
+    if (it->second == ue_index) {
+      rnti_to_ue_index.erase(it);
+      break;
+    }
+  }
 }
 
 void scheduler_test_simulator::push_dl_buffer_state(const dl_buffer_state_indication_message& upd)
@@ -114,7 +129,12 @@ void scheduler_test_simulator::run_slot(du_cell_index_t cell_idx)
 
   last_sched_res_list[cell_idx] = &sched->slot_indication(next_slot, cell_idx);
 
+  // Ensure the scheduler result is consistent with the cell configuration and there are no collisions.
   test_scheduler_result_consistency(cell_cfg_list[cell_idx], next_slot, *last_sched_res_list[cell_idx]);
+
+  // In case auto-feedback is enabled, handle it.
+  handle_auto_feedback(cell_idx);
+
   ++next_slot;
 }
 
@@ -129,3 +149,51 @@ bool scheduler_test_simulator::run_slot_until(const std::function<bool()>& cond_
   }
   return count < slot_timeout;
 }
+
+void scheduler_test_simulator::handle_auto_feedback(du_cell_index_t cell_idx)
+{
+  if (not auto_uci and not auto_crc) {
+    return;
+  }
+  // Note: next_slot hasn't been incremented yet.
+  slot_point sl_rx = next_slot;
+
+  uci_indication uci_ind;
+  uci_ind.cell_index = cell_idx;
+  uci_ind.slot_rx    = sl_rx;
+  ul_crc_indication crc_ind;
+  crc_ind.cell_index = cell_idx;
+  crc_ind.sl_rx      = sl_rx;
+
+  if (auto_uci) {
+    // Handle PUCCHs.
+    for (const pucch_info& pucch : this->last_sched_res_list[cell_idx]->ul.pucchs) {
+      if (pucch.format() == pucch_format::FORMAT_1 and pucch.uci_bits.sr_bits != sr_nof_bits::no_sr) {
+        // Skip SRs.
+        continue;
+      }
+
+      const du_ue_index_t ue_idx = rnti_to_ue_index.at(pucch.crnti);
+      uci_ind.ucis.push_back(test_helper::create_uci_indication_pdu(ue_idx, pucch));
+    }
+  }
+
+  for (const auto& pusch : this->last_sched_res_list[cell_idx]->ul.puschs) {
+    if (auto_uci and pusch.uci.has_value()) {
+      const du_ue_index_t ue_idx = pusch.context.ue_index;
+      uci_ind.ucis.push_back(test_helper::create_uci_indication_pdu(pusch.pusch_cfg.rnti, ue_idx, pusch.uci.value()));
+    }
+
+    if (auto_crc) {
+      crc_ind.crcs.push_back(test_helper::create_crc_pdu_indication(pusch));
+    }
+  }
+
+  // Forward indications to the scheduler.
+  if (not uci_ind.ucis.empty()) {
+    this->sched->handle_uci_indication(uci_ind);
+  }
+  if (not crc_ind.crcs.empty()) {
+    this->sched->handle_crc_indication(crc_ind);
+  }
+}

tests/unittests/scheduler/test_utils/scheduler_test_simulator.h

@@ -10,17 +10,28 @@
 
 #pragma once
 
+#include "config_generators.h"
 #include "dummy_test_components.h"
 #include "lib/scheduler/config/cell_configuration.h"
 #include "result_test_helpers.h"
 #include "srsran/du/du_cell_config_helpers.h"
-#include "srsran/scheduler/scheduler_configurator.h"
 #include "srsran/scheduler/scheduler_factory.h"
 
 namespace srsran {
 
 scheduler_expert_config make_custom_scheduler_expert_config(bool enable_csi_rs_pdsch_multiplexing);
 
+/// Configuration of the scheduler test simulator.
+struct scheduler_test_sim_config {
+  scheduler_expert_config sched_cfg   = config_helpers::make_default_scheduler_expert_config();
+  unsigned                tx_rx_delay = 4;
+  subcarrier_spacing      max_scs     = subcarrier_spacing::kHz15;
+  /// Whether to automatically respond to UCI grants with UCI indications.
+  bool auto_uci = false;
+  /// Whether to automatically respond to PUSCH grants with CRC indications.
+  bool auto_crc = false;
+};
+
 /// Helper class to help setup a scheduler unit test.
 class scheduler_test_simulator
 {
@@ -31,6 +42,7 @@ class scheduler_test_simulator
   explicit scheduler_test_simulator(const scheduler_expert_config& sched_cfg_,
                                     unsigned                       tx_rx_delay_ = 4,
                                     subcarrier_spacing             max_scs      = subcarrier_spacing::kHz15);
+  explicit scheduler_test_simulator(const scheduler_test_sim_config& cfg);
   ~scheduler_test_simulator();
 
   slot_point next_slot_rx() const { return next_slot - tx_rx_delay; }
@@ -71,6 +83,8 @@ class scheduler_test_simulator
   }
 
   const unsigned                      tx_rx_delay;
+  bool                                auto_uci = false;
+  bool                                auto_crc = false;
   srslog::basic_logger&               logger;
   srslog::basic_logger&               test_logger;
   const scheduler_expert_config       sched_cfg;
@@ -82,6 +96,12 @@ class scheduler_test_simulator
 
   slot_point                                           next_slot;
   static_vector<const sched_result*, MAX_NOF_DU_CELLS> last_sched_res_list;
+
+private:
+  /// Handle automatic feedback (UCI/CRC) if enabled.
+  void handle_auto_feedback(du_cell_index_t cell_idx);
+
+  std::unordered_map<rnti_t, du_ue_index_t> rnti_to_ue_index;
 };
 
 } // namespace srsran