sched: add missing methods to unique_ue_harq_entity

Author: frankist

lib/scheduler/cell/cell_harq_manager.cpp

@@ -21,7 +21,7 @@ class noop_harq_timeout_notifier : public harq_timeout_notifier
 {
 public:
   void on_harq_timeout(du_ue_index_t ue_idx, bool is_dl, bool ack) override
-  { /* do nothing */
+  { // do nothing
   }
 };
 
@@ -322,6 +322,12 @@ void harq_utils::base_harq_process_handle<IsDl>::cancel_retxs()
   harq_repo->cancel_retxs(*impl);
 }
 
+template <bool IsDl>
+void harq_utils::base_harq_process_handle<IsDl>::reset()
+{
+  harq_repo->dealloc_harq(*impl);
+}
+
 template class harq_utils::base_harq_process_handle<true>;
 template class harq_utils::base_harq_process_handle<false>;
 
@@ -472,7 +478,7 @@ void dl_harq_process_handle::increment_pucch_counter()
   ++impl->pucch_ack_to_receive;
 }
 
-void dl_harq_process_handle::save_grant_params(const dl_harq_sched_context& ctx, const pdsch_information& pdsch)
+void dl_harq_process_handle::save_grant_params(const dl_harq_alloc_context& ctx, const pdsch_information& pdsch)
 {
   srsran_assert(pdsch.codewords.size() == 1, "Only one codeword supported");
   srsran_sanity_check(pdsch.rnti == impl->rnti, "RNTI mismatch");
@@ -530,7 +536,7 @@ int ul_harq_process_handle::ul_crc_info(bool ack)
   return ack ? (int)impl->prev_tx_params.tbs_bytes : 0;
 }
 
-void ul_harq_process_handle::save_grant_params(const ul_harq_sched_context& ctx, const pusch_information& pusch)
+void ul_harq_process_handle::save_grant_params(const ul_harq_alloc_context& ctx, const pusch_information& pusch)
 {
   srsran_sanity_check(pusch.rnti == impl->rnti, "RNTI mismatch");
   srsran_sanity_check(pusch.harq_id == impl->h_id, "HARQ-id mismatch");
@@ -626,6 +632,15 @@ std::optional<dl_harq_process_handle> unique_ue_harq_entity::find_pending_dl_ret
   return dl_harq_process_handle(cell_harq_mgr->dl, *h);
 }
 
+std::optional<const dl_harq_process_handle> unique_ue_harq_entity::find_pending_dl_retx() const
+{
+  dl_harq_process_impl* h = cell_harq_mgr->dl.find_ue_harq_in_state(ue_index, harq_state_t::pending_retx);
+  if (h == nullptr) {
+    return std::nullopt;
+  }
+  return dl_harq_process_handle(cell_harq_mgr->dl, *h);
+}
+
 std::optional<ul_harq_process_handle> unique_ue_harq_entity::find_pending_ul_retx()
 {
   ul_harq_process_impl* h = cell_harq_mgr->ul.find_ue_harq_in_state(ue_index, harq_state_t::pending_retx);
@@ -635,6 +650,15 @@ std::optional<ul_harq_process_handle> unique_ue_harq_entity::find_pending_ul_ret
   return ul_harq_process_handle(cell_harq_mgr->ul, *h);
 }
 
+std::optional<const ul_harq_process_handle> unique_ue_harq_entity::find_pending_ul_retx() const
+{
+  ul_harq_process_impl* h = cell_harq_mgr->ul.find_ue_harq_in_state(ue_index, harq_state_t::pending_retx);
+  if (h == nullptr) {
+    return std::nullopt;
+  }
+  return ul_harq_process_handle(cell_harq_mgr->ul, *h);
+}
+
 std::optional<dl_harq_process_handle> unique_ue_harq_entity::find_dl_harq_waiting_ack()
 {
   dl_harq_process_impl* h = cell_harq_mgr->dl.find_ue_harq_in_state(ue_index, harq_state_t::waiting_ack);
@@ -675,3 +699,17 @@ std::optional<ul_harq_process_handle> unique_ue_harq_entity::find_ul_harq(slot_p
   }
   return std::nullopt;
 }
+
+void unique_ue_harq_entity::uci_sched_failed(slot_point uci_slot)
+{
+  std::vector<dl_harq_process_impl>& dl_harqs = cell_harq_mgr->dl.ues[ue_index].harqs;
+  for (dl_harq_process_impl& h : dl_harqs) {
+    if (h.status == harq_utils::harq_state_t::waiting_ack and h.slot_ack == uci_slot) {
+      unsigned nof_nacks = std::max(h.pucch_ack_to_receive, 1U);
+      auto     h_handle  = dl_harq_process_handle(cell_harq_mgr->dl, h);
+      for (unsigned i = 0; i != nof_nacks; ++i) {
+        h_handle.dl_ack_info(mac_harq_ack_report_status::dtx, std::nullopt);
+      }
+    }
+  }
+}

lib/scheduler/cell/cell_harq_manager.h

@@ -170,20 +170,24 @@ class base_harq_process_handle
   base_harq_process_handle() = default;
   base_harq_process_handle(harq_pool& pool_, harq_impl_type& h_) : harq_repo(&pool_), impl(&h_) {}
 
-  rnti_t    rnti() const { return impl->rnti; }
-  harq_id_t id() const { return impl->h_id; }
-  bool      is_waiting_ack() const { return impl->status == harq_utils::harq_state_t::waiting_ack; }
-  bool      has_pending_retx() const { return impl->status == harq_utils::harq_state_t::pending_retx; }
-  bool      empty() const { return impl->status == harq_utils::harq_state_t::empty; }
-  unsigned  max_nof_retxs() const { return impl->max_nof_harq_retxs; }
-  unsigned  nof_retxs() const { return impl->nof_retxs; }
-  bool      ndi() const { return impl->ndi; }
+  du_ue_index_t ue_index() const { return impl->ue_idx; }
+  rnti_t        rnti() const { return impl->rnti; }
+  harq_id_t     id() const { return impl->h_id; }
+  bool          is_waiting_ack() const { return impl->status == harq_utils::harq_state_t::waiting_ack; }
+  bool          has_pending_retx() const { return impl->status == harq_utils::harq_state_t::pending_retx; }
+  bool          empty() const { return impl->status == harq_utils::harq_state_t::empty; }
+  unsigned      max_nof_retxs() const { return impl->max_nof_harq_retxs; }
+  unsigned      nof_retxs() const { return impl->nof_retxs; }
+  bool          ndi() const { return impl->ndi; }
 
   /// \brief Cancels any retransmissions for this HARQ process.
   /// If the HARQ process has a pending retransmission, it is reset. If the ACK/CRC info has not been received yet, the
   /// HARQ process waits for it to arrive before being reset.
   void cancel_retxs();
 
+  /// Empty the HARQ process.
+  void reset();
+
   bool operator==(const base_harq_process_handle& other) const
   {
     return harq_repo == other.harq_repo and impl == other.impl;
@@ -198,7 +202,7 @@ class base_harq_process_handle
 } // namespace harq_utils
 
 /// \brief Context of the scheduler during the current PDSCH allocation.
-struct dl_harq_sched_context {
+struct dl_harq_alloc_context {
   /// DCI format used to signal the PDSCH allocation.
   dci_dl_rnti_config_type dci_cfg_type;
   /// MCS suggested by the OLLA.
@@ -212,7 +216,7 @@ struct dl_harq_sched_context {
 };
 
 /// \brief Context of the scheduler during the current PUSCH allocation.
-struct ul_harq_sched_context {
+struct ul_harq_alloc_context {
   /// DCI format used to signal the PUSCH allocation.
   dci_ul_rnti_config_type dci_cfg_type;
   /// MCS suggested by the OLLA.
@@ -261,7 +265,7 @@ class dl_harq_process_handle : public harq_utils::base_harq_process_handle<true>
 
   /// \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);
+  void save_grant_params(const dl_harq_alloc_context& ctx, const pdsch_information& pdsch);
 
   slot_point pdsch_slot() const { return impl->slot_tx; }
   slot_point uci_slot() const { return impl->slot_ack; }
@@ -300,7 +304,7 @@ class ul_harq_process_handle : public harq_utils::base_harq_process_handle<false
 
   /// \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& pusch);
+  void save_grant_params(const ul_harq_alloc_context& ctx, const pusch_information& pusch);
 
   slot_point pusch_slot() const { return impl->slot_tx; }
 
@@ -436,6 +440,8 @@ class unique_ue_harq_entity
   unique_ue_harq_entity& operator=(const unique_ue_harq_entity&) = delete;
   unique_ue_harq_entity& operator=(unique_ue_harq_entity&& other) noexcept;
 
+  bool empty() const { return cell_harq_mgr == nullptr; }
+
   /// Gets the maximum number of HARQ processes a UE can use, which depends on its configuration.
   unsigned nof_dl_harqs() const { return get_dl_ue().harqs.size(); }
   unsigned nof_ul_harqs() const { return get_ul_ue().harqs.size(); }
@@ -454,20 +460,36 @@ class unique_ue_harq_entity
     }
     return std::nullopt;
   }
+  std::optional<const dl_harq_process_handle> dl_harq(harq_id_t h_id) const
+  {
+    if (get_dl_ue().harqs[h_id].status != harq_utils::harq_state_t::empty) {
+      return dl_harq_process_handle{cell_harq_mgr->dl, cell_harq_mgr->dl.ues[ue_index].harqs[h_id]};
+    }
+    return std::nullopt;
+  }
   std::optional<ul_harq_process_handle> ul_harq(harq_id_t h_id)
   {
     if (get_ul_ue().harqs[h_id].status != harq_utils::harq_state_t::empty) {
       return ul_harq_process_handle{cell_harq_mgr->ul, get_ul_ue().harqs[h_id]};
     }
     return std::nullopt;
   }
+  std::optional<const ul_harq_process_handle> ul_harq(harq_id_t h_id) const
+  {
+    if (get_ul_ue().harqs[h_id].status != harq_utils::harq_state_t::empty) {
+      return ul_harq_process_handle{cell_harq_mgr->ul, cell_harq_mgr->ul.ues[ue_index].harqs[h_id]};
+    }
+    return std::nullopt;
+  }
 
   std::optional<dl_harq_process_handle>
   alloc_dl_harq(slot_point sl_tx, unsigned k1, unsigned max_harq_nof_retxs, unsigned harq_bit_idx);
   std::optional<ul_harq_process_handle> alloc_ul_harq(slot_point sl_tx, unsigned max_harq_nof_retxs);
 
-  std::optional<dl_harq_process_handle> find_pending_dl_retx();
-  std::optional<ul_harq_process_handle> find_pending_ul_retx();
+  std::optional<dl_harq_process_handle>       find_pending_dl_retx();
+  std::optional<const dl_harq_process_handle> find_pending_dl_retx() const;
+  std::optional<ul_harq_process_handle>       find_pending_ul_retx();
+  std::optional<const ul_harq_process_handle> find_pending_ul_retx() const;
 
   std::optional<dl_harq_process_handle> find_dl_harq_waiting_ack();
   std::optional<ul_harq_process_handle> find_ul_harq_waiting_ack();
@@ -483,6 +505,18 @@ class unique_ue_harq_entity
   /// \return Active UL HARQ process with matching PUSCH slot, if found.
   std::optional<ul_harq_process_handle> find_ul_harq(slot_point pusch_slot);
 
+  /// \brief The UCI scheduling associated with a given slot was cancelled. The associated DL HARQs will be NACKed, and
+  /// won't expect further UCIs.
+  ///
+  /// This function can be called for instance when there is an error indication coming from lower layers.
+  void uci_sched_failed(slot_point uci_slot);
+
+  unsigned ntn_get_tbs_pending_crcs() const
+  {
+    // TODO
+    return 0;
+  }
+
 private:
   dl_harq_ent_impl&       get_dl_ue() { return cell_harq_mgr->dl.ues[ue_index]; }
   const dl_harq_ent_impl& get_dl_ue() const { return cell_harq_mgr->dl.ues[ue_index]; }
@@ -494,4 +528,4 @@ class unique_ue_harq_entity
   rnti_t             crnti         = rnti_t::INVALID_RNTI;
 };
 
-} // namespace srsran
+} // namespace srsran

tests/unittests/scheduler/cell/cell_harq_manager_test.cpp

@@ -155,10 +155,10 @@ class single_harq_process_test : public base_single_harq_entity_test, public ::t
   single_harq_process_test()
   {
     pdsch_info = make_dummy_pdsch_info();
-    dl_harq_sched_context harq_ctxt{dci_dl_rnti_config_type::c_rnti_f1_0};
+    dl_harq_alloc_context harq_ctxt{dci_dl_rnti_config_type::c_rnti_f1_0};
     h_dl.save_grant_params(harq_ctxt, pdsch_info);
     pusch_info = make_dummy_pusch_info();
-    ul_harq_sched_context ul_harq_ctxt{dci_ul_rnti_config_type::c_rnti_f0_0};
+    ul_harq_alloc_context ul_harq_ctxt{dci_ul_rnti_config_type::c_rnti_f0_0};
     h_ul.save_grant_params(ul_harq_ctxt, pusch_info);
   }