sched: extend harq_manager_test to cover all scenarios previously tested in harq_process_test

Author: frankist

lib/scheduler/ue_scheduling/cell_harq_manager.cpp

@@ -9,6 +9,7 @@
  */
 
 #include "cell_harq_manager.h"
+#include "srsran/scheduler/scheduler_slot_handler.h"
 
 using namespace srsran;
 using namespace harq_utils;
@@ -219,9 +220,12 @@ void cell_harq_repository<IsDl>::set_pending_retx(harq_type& h)
 }
 
 template <bool IsDl>
-void cell_harq_repository<IsDl>::handle_new_retx(harq_type& h, slot_point sl_tx, slot_point sl_ack)
+bool cell_harq_repository<IsDl>::handle_new_retx(harq_type& h, slot_point sl_tx, slot_point sl_ack)
 {
-  srsran_assert(h.status == harq_state_t::pending_retx, "Attempt of retx in an HARQ that has no pending retx");
+  if (h.status != harq_state_t::pending_retx) {
+    logger.warning("ue={} h_id={}: Attempt of retx in a HARQ process that has no pending retx", h.ue_idx, h.h_id);
+    return false;
+  }
 
   // Remove HARQ from pending Retx list.
   harq_pending_retx_list.pop(&h);
@@ -237,6 +241,7 @@ void cell_harq_repository<IsDl>::handle_new_retx(harq_type& h, slot_point sl_tx,
   // Add HARQ to the timeout list.
   h.slot_ack_timeout = sl_ack + max_ack_wait_in_slots;
   harq_timeout_wheel[h.slot_ack_timeout.to_uint() % harq_timeout_wheel.size()].push_front(&h);
+  return true;
 }
 
 template <bool IsDl>
@@ -367,21 +372,24 @@ cell_harq_manager::new_ul_tx(du_ue_index_t ue_idx, slot_point pusch_slot, unsign
   return h;
 }
 
-void cell_harq_manager::new_dl_retx(harq_utils::dl_harq_process_impl& h,
+bool cell_harq_manager::new_dl_retx(harq_utils::dl_harq_process_impl& h,
                                     slot_point                        pdsch_slot,
                                     unsigned                          k1,
                                     uint8_t                           harq_bit_idx)
 {
-  dl.handle_new_retx(h, pdsch_slot, pdsch_slot + k1);
+  if (not dl.handle_new_retx(h, pdsch_slot, pdsch_slot + k1)) {
+    return false;
+  }
   h.harq_bit_idx         = harq_bit_idx;
   h.pucch_ack_to_receive = 0;
   h.chosen_ack           = mac_harq_ack_report_status::dtx;
   h.last_pucch_snr       = std::nullopt;
+  return true;
 }
 
-void cell_harq_manager::new_ul_retx(harq_utils::ul_harq_process_impl& h, slot_point pusch_slot)
+bool cell_harq_manager::new_ul_retx(harq_utils::ul_harq_process_impl& h, slot_point pusch_slot)
 {
-  ul.handle_new_retx(h, pusch_slot, pusch_slot);
+  return ul.handle_new_retx(h, pusch_slot, pusch_slot);
 }
 
 dl_harq_process_impl::status_update cell_harq_manager::dl_ack_info(harq_utils::dl_harq_process_impl& h,
@@ -438,32 +446,91 @@ int cell_harq_manager::ul_crc_info(harq_utils::ul_harq_process_impl& h, bool ack
   return ack ? (int)h.prev_tx_params.tbs_bytes : 0;
 }
 
-void dl_harq_process_view::new_retx(slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx)
+bool dl_harq_process_view::new_retx(slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx)
 {
-  cell_harq_mng->new_dl_retx(cell_harq_mng->dl.harqs[harq_ref_idx], pdsch_slot, k1, harq_bit_idx);
+  return cell_harq_mng->new_dl_retx(fetch_impl(), pdsch_slot, k1, harq_bit_idx);
 }
 
 dl_harq_process_view::status_update dl_harq_process_view::dl_ack_info(mac_harq_ack_report_status ack,
                                                                       std::optional<float>       pucch_snr)
 {
-  return cell_harq_mng->dl_ack_info(cell_harq_mng->dl.harqs[harq_ref_idx], ack, pucch_snr);
+  return cell_harq_mng->dl_ack_info(fetch_impl(), ack, pucch_snr);
 }
 
 void dl_harq_process_view::increment_pucch_counter()
 {
-  ++cell_harq_mng->dl.harqs[harq_ref_idx].pucch_ack_to_receive;
+  ++fetch_impl().pucch_ack_to_receive;
 }
 
-void ul_harq_process_view::new_retx(slot_point pusch_slot)
+void dl_harq_process_view::save_grant_params(const dl_harq_sched_context& ctx, const pdsch_information& pdsch)
 {
-  cell_harq_mng->new_ul_retx(cell_harq_mng->ul.harqs[harq_ref_idx], pusch_slot);
+  srsran_assert(pdsch.codewords.size() == 1, "Only one codeword supported");
+  dl_harq_process_impl& impl = fetch_impl();
+  srsran_assert(impl.status == harq_utils::harq_state_t::waiting_ack,
+                "Setting allocation parameters for DL HARQ process id={} in invalid state",
+                id());
+
+  const pdsch_codeword&               cw          = pdsch.codewords[0];
+  dl_harq_process_impl::alloc_params& prev_params = impl.prev_tx_params;
+
+  if (impl.nof_retxs == 0) {
+    prev_params.tbs_bytes    = cw.tb_size_bytes;
+    prev_params.dci_cfg_type = ctx.dci_cfg_type;
+    prev_params.olla_mcs     = ctx.olla_mcs;
+    prev_params.slice_id     = ctx.slice_id;
+  } else {
+    srsran_assert(ctx.dci_cfg_type == prev_params.dci_cfg_type,
+                  "DCI format and RNTI type cannot change during DL HARQ retxs");
+    srsran_assert(prev_params.tbs_bytes == cw.tb_size_bytes,
+                  "TBS cannot change during DL HARQ retxs ({}!={}). Previous MCS={}, RBs={}. New MCS={}, RBs={}",
+                  prev_params.tbs_bytes,
+                  cw.tb_size_bytes,
+                  prev_params.mcs,
+                  prev_params.rbs,
+                  cw.mcs_index,
+                  pdsch.rbs);
+  }
+  prev_params.mcs_table   = cw.mcs_table;
+  prev_params.mcs         = cw.mcs_index;
+  prev_params.rbs         = pdsch.rbs;
+  prev_params.nof_symbols = pdsch.symbols.length();
+}
+
+bool ul_harq_process_view::new_retx(slot_point pusch_slot)
+{
+  return cell_harq_mng->new_ul_retx(cell_harq_mng->ul.harqs[harq_ref_idx], pusch_slot);
 }
 
 int ul_harq_process_view::ul_crc_info(bool ack)
 {
   return cell_harq_mng->ul_crc_info(cell_harq_mng->ul.harqs[harq_ref_idx], ack);
 }
 
+void ul_harq_process_view::save_grant_params(const ul_harq_sched_context& ctx, const pusch_information& pusch)
+{
+  ul_harq_process_impl& impl = fetch_impl();
+  srsran_assert(impl.status == harq_utils::harq_state_t::waiting_ack,
+                "Setting allocation parameters for DL HARQ process id={} in invalid state",
+                id());
+
+  ul_harq_process_impl::alloc_params& prev_tx_params = impl.prev_tx_params;
+
+  if (impl.nof_retxs == 0) {
+    prev_tx_params.dci_cfg_type = ctx.dci_cfg_type;
+    prev_tx_params.olla_mcs     = ctx.olla_mcs;
+    prev_tx_params.tbs_bytes    = pusch.tb_size_bytes;
+    prev_tx_params.slice_id     = ctx.slice_id;
+  } else {
+    srsran_assert(ctx.dci_cfg_type == prev_tx_params.dci_cfg_type,
+                  "DCI format and RNTI type cannot change during HARQ retxs");
+    srsran_assert(prev_tx_params.tbs_bytes == pusch.tb_size_bytes, "TBS cannot change during HARQ retxs");
+  }
+  prev_tx_params.mcs_table   = pusch.mcs_table;
+  prev_tx_params.mcs         = pusch.mcs_index;
+  prev_tx_params.rbs         = pusch.rbs;
+  prev_tx_params.nof_symbols = pusch.symbols.length();
+}
+
 // UE HARQ entity.
 
 unique_ue_harq_entity::unique_ue_harq_entity(unique_ue_harq_entity&& other) noexcept :

lib/scheduler/ue_scheduling/cell_harq_manager.h

@@ -10,6 +10,7 @@
 
 #pragma once
 
+#include "../slicing/ran_slice_id.h"
 #include "srsran/adt/intrusive_list.h"
 #include "srsran/adt/optional.h"
 #include "srsran/ran/csi_report/csi_report_data.h"
@@ -24,6 +25,9 @@
 
 namespace srsran {
 
+struct pdsch_information;
+struct pusch_information;
+
 class unique_ue_harq_entity;
 
 /// \brief Notifier of HARQ process timeouts.
@@ -79,6 +83,8 @@ struct dl_harq_process_impl : public base_harq_process {
     pdsch_mcs_table         mcs_table;
     sch_mcs_index           mcs;
     unsigned                tbs_bytes;
+    /// RAN slice identifier.
+    std::optional<ran_slice_id_t> slice_id;
     /// \brief MCS originally suggested by the OLLA. It might differ from the actual MCS used.
     std::optional<sch_mcs_index> olla_mcs;
   };
@@ -99,13 +105,14 @@ struct dl_harq_process_impl : public base_harq_process {
 struct ul_harq_process_impl : public base_harq_process {
   /// \brief Parameters relative to the last allocated PUSCH PDU for this HARQ process.
   struct alloc_params {
-    dci_ul_rnti_config_type      dci_cfg_type;
-    vrb_alloc                    rbs;
-    pusch_mcs_table              mcs_table;
-    sch_mcs_index                mcs;
-    unsigned                     tbs_bytes;
-    unsigned                     nof_symbols;
-    std::optional<sch_mcs_index> olla_mcs;
+    dci_ul_rnti_config_type       dci_cfg_type;
+    vrb_alloc                     rbs;
+    pusch_mcs_table               mcs_table;
+    sch_mcs_index                 mcs;
+    unsigned                      tbs_bytes;
+    unsigned                      nof_symbols;
+    std::optional<ran_slice_id_t> slice_id;
+    std::optional<sch_mcs_index>  olla_mcs;
   };
 
   /// Parameters used for the last Tx of this HARQ process.
@@ -139,21 +146,41 @@ struct cell_harq_repository {
 
   unsigned get_harq_ref_idx(const harq_type& h) const;
 
-  void       slot_indication(slot_point sl_tx);
-  void       handle_harq_ack_timeout(harq_type& h, slot_point sl_tx);
-  harq_type* alloc_harq(du_ue_index_t ue_idx, slot_point sl_tx, slot_point sl_ack, unsigned max_nof_harq_retxs);
-  void       dealloc_harq(harq_type& h);
-  void       handle_ack(harq_type& h, bool ack);
-  void       set_pending_retx(harq_type& h);
-  void       handle_new_retx(harq_type& h, slot_point sl_tx, slot_point sl_ack);
-  void       reserve_ue_harqs(du_ue_index_t ue_idx, unsigned nof_harqs);
-  void       destroy_ue_harqs(du_ue_index_t ue_idx);
-  void       cancel_retxs(harq_type& h);
-  unsigned   find_ue_harq_in_state(du_ue_index_t ue_idx, harq_utils::harq_state_t state) const;
+  void               slot_indication(slot_point sl_tx);
+  void               handle_harq_ack_timeout(harq_type& h, slot_point sl_tx);
+  harq_type*         alloc_harq(du_ue_index_t ue_idx, slot_point sl_tx, slot_point sl_ack, unsigned max_nof_harq_retxs);
+  void               dealloc_harq(harq_type& h);
+  void               handle_ack(harq_type& h, bool ack);
+  void               set_pending_retx(harq_type& h);
+  [[nodiscard]] bool handle_new_retx(harq_type& h, slot_point sl_tx, slot_point sl_ack);
+  void               reserve_ue_harqs(du_ue_index_t ue_idx, unsigned nof_harqs);
+  void               destroy_ue_harqs(du_ue_index_t ue_idx);
+  void               cancel_retxs(harq_type& h);
+  unsigned           find_ue_harq_in_state(du_ue_index_t ue_idx, harq_utils::harq_state_t state) const;
 };
 
 } // namespace harq_utils
 
+/// \brief Context of the scheduler during the current PDSCH allocation.
+struct dl_harq_sched_context {
+  /// DCI format used to signal the PDSCH allocation.
+  dci_dl_rnti_config_type dci_cfg_type;
+  /// MCS suggested by the OLLA.
+  std::optional<sch_mcs_index> olla_mcs;
+  /// RAN slice identifier of the slice to which PDSCH belongs to.
+  std::optional<ran_slice_id_t> slice_id;
+};
+
+/// \brief Context of the scheduler during the current PUSCH allocation.
+struct ul_harq_sched_context {
+  /// DCI format used to signal the PUSCH allocation.
+  dci_ul_rnti_config_type dci_cfg_type;
+  /// MCS suggested by the OLLA.
+  std::optional<sch_mcs_index> olla_mcs;
+  /// RAN slice identifier of the slice to which PUSCH belongs to.
+  std::optional<ran_slice_id_t> slice_id;
+};
+
 class cell_harq_manager
 {
 public:
@@ -206,10 +233,11 @@ class cell_harq_manager
   harq_utils::ul_harq_process_impl* new_ul_tx(du_ue_index_t ue_idx, slot_point pusch_slot, unsigned max_harq_nof_retxs);
 
   /// \brief Called on a new retx of a DL HARQ process.
-  void new_dl_retx(harq_utils::dl_harq_process_impl& h, slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx);
+  [[nodiscard]] bool
+  new_dl_retx(harq_utils::dl_harq_process_impl& h, slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx);
 
   /// \brief Called on a new retx of a UL HARQ process.
-  void new_ul_retx(harq_utils::ul_harq_process_impl& h, slot_point pusch_slot);
+  [[nodiscard]] bool new_ul_retx(harq_utils::ul_harq_process_impl& h, slot_point pusch_slot);
 
   /// Updates a DL HARQ process given the received HARQ-ACK info.
   harq_utils::dl_harq_process_impl::status_update
@@ -241,18 +269,15 @@ class dl_harq_process_view
                         "Empty HARQ process created");
   }
 
-  harq_id_t id() const { return cell_harq_mng->dl.harqs[harq_ref_idx].h_id; }
-
-  bool is_waiting_ack() const
+  harq_id_t id() const { return fetch_impl().h_id; }
+  bool      is_waiting_ack() const { return fetch_impl().status == harq_utils::harq_state_t::waiting_ack; }
+  bool      has_pending_retx() const { return fetch_impl().status == harq_utils::harq_state_t::pending_retx; }
+  bool      empty() const
   {
-    return cell_harq_mng->dl.harqs[harq_ref_idx].status == harq_utils::harq_state_t::waiting_ack;
-  }
-  bool has_pending_retx() const
-  {
-    return cell_harq_mng->dl.harqs[harq_ref_idx].status == harq_utils::harq_state_t::pending_retx;
+    return harq_ref_idx == cell_harq_manager::INVALID_HARQ or fetch_impl().status == harq_utils::harq_state_t::empty;
   }
 
-  void new_retx(slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx);
+  [[nodiscard]] bool new_retx(slot_point pdsch_slot, unsigned k1, uint8_t harq_bit_idx);
 
   /// \brief Update the state of the DL HARQ process waiting for an HARQ-ACK.
   /// \param[in] ack HARQ-ACK status received.
@@ -262,7 +287,17 @@ class dl_harq_process_view
 
   void increment_pucch_counter();
 
-  const grant_params& get_grant_params() const { return cell_harq_mng->dl.harqs[harq_ref_idx].prev_tx_params; }
+  /// \brief Stores grant parameters that are associated with the HARQ process (e.g. DCI format, PRBs, MCS) so that
+  /// they can be later fetched and optionally reused.
+  void save_grant_params(const dl_harq_sched_context& ctx, const pdsch_information& pdsch);
+
+  slot_point pdsch_slot() const { return fetch_impl().slot_tx; }
+  slot_point uci_slot() const { return fetch_impl().slot_ack; }
+  unsigned   max_nof_retxs() const { return fetch_impl().max_nof_harq_retxs; }
+  unsigned   nof_retxs() const { return fetch_impl().nof_retxs; }
+  bool       ndi() const { return fetch_impl().ndi; }
+
+  const grant_params& get_grant_params() const { return fetch_impl().prev_tx_params; }
 
   bool operator==(const dl_harq_process_view& other) const
   {
@@ -271,6 +306,9 @@ class dl_harq_process_view
   bool operator!=(const dl_harq_process_view& other) const { return !(*this == other); }
 
 private:
+  harq_utils::dl_harq_process_impl&       fetch_impl() { return cell_harq_mng->dl.harqs[harq_ref_idx]; }
+  const harq_utils::dl_harq_process_impl& fetch_impl() const { return cell_harq_mng->dl.harqs[harq_ref_idx]; }
+
   cell_harq_manager* cell_harq_mng = nullptr;
   unsigned           harq_ref_idx  = cell_harq_manager::INVALID_HARQ;
 };
@@ -281,34 +319,39 @@ class ul_harq_process_view
   ul_harq_process_view(cell_harq_manager& cell_harq_mng_, unsigned h_ref_idx) :
     cell_harq_mng(&cell_harq_mng_), harq_ref_idx(h_ref_idx)
   {
-    srsran_sanity_check(cell_harq_mng->ul.harqs[harq_ref_idx].status != harq_utils::harq_state_t::empty,
-                        "Empty HARQ process created");
+    srsran_sanity_check(fetch_impl().status != harq_utils::harq_state_t::empty, "Empty HARQ process created");
   }
 
-  harq_id_t id() const { return cell_harq_mng->ul.harqs[harq_ref_idx].h_id; }
+  harq_id_t id() const { return fetch_impl().h_id; }
 
-  bool is_waiting_ack() const
-  {
-    return cell_harq_mng->ul.harqs[harq_ref_idx].status == harq_utils::harq_state_t::waiting_ack;
-  }
-  bool has_pending_retx() const
-  {
-    return cell_harq_mng->ul.harqs[harq_ref_idx].status == harq_utils::harq_state_t::pending_retx;
-  }
+  bool is_waiting_ack() const { return fetch_impl().status == harq_utils::harq_state_t::waiting_ack; }
+  bool has_pending_retx() const { return fetch_impl().status == harq_utils::harq_state_t::pending_retx; }
 
-  void new_retx(slot_point pusch_slot);
+  [[nodiscard]] bool new_retx(slot_point pusch_slot);
 
   /// Update UL HARQ state given the received CRC indication.
   /// \return Transport Block size of the HARQ whose state was updated.
   int ul_crc_info(bool ack);
 
+  /// \brief Stores grant parameters that are associated with the HARQ process (e.g. DCI format, PRBs, MCS) so that
+  /// they can be later fetched and optionally reused.
+  void save_grant_params(const ul_harq_sched_context& ctx, const pusch_information& pdsch);
+
+  slot_point pusch_slot() const { return fetch_impl().slot_tx; }
+  unsigned   max_nof_retxs() const { return fetch_impl().max_nof_harq_retxs; }
+  unsigned   nof_retxs() const { return fetch_impl().nof_retxs; }
+  bool       ndi() const { return fetch_impl().ndi; }
+
   bool operator==(const ul_harq_process_view& other) const
   {
     return cell_harq_mng == other.cell_harq_mng and harq_ref_idx == other.harq_ref_idx;
   }
   bool operator!=(const ul_harq_process_view& other) const { return !(*this == other); }
 
 private:
+  harq_utils::ul_harq_process_impl&       fetch_impl() { return cell_harq_mng->ul.harqs[harq_ref_idx]; }
+  const harq_utils::ul_harq_process_impl& fetch_impl() const { return cell_harq_mng->ul.harqs[harq_ref_idx]; }
+
   cell_harq_manager* cell_harq_mng = nullptr;
   unsigned           harq_ref_idx  = cell_harq_manager::INVALID_HARQ;
 };

tests/unittests/scheduler/ue_scheduling/CMakeLists.txt

@@ -9,7 +9,6 @@
 add_executable(ue_scheduler_test
         logical_channel_test.cpp
         harq_manager_test.cpp
-        harq_entity_test.cpp
         harq_process_test.cpp
         fallback_scheduler_test.cpp
         ue_cell_test.cpp
@@ -28,5 +27,4 @@ target_link_libraries(ue_scheduler_test
         sched_config
         gtest
         gtest_main)
-gtest_discover_tests(ue_scheduler_test)
 add_test(ue_scheduler_test ue_scheduler_test)