sched: integrate new HARQ manager in RA scheduler

frankist · frankist · commit e249f59eb4d9 · 2024-08-30T17:11:06.000+02:00
diff --git a/lib/scheduler/cell/cell_harq_manager.cpp b/lib/scheduler/cell/cell_harq_manager.cpp
@@ -206,14 +206,17 @@ void cell_harq_repository<IsDl>::slot_indication(slot_point sl_tx)
       break;
     }
 
-    // HARQ is trapped. Remove it.
+    // HARQ retransmission is trapped. Deallocate HARQ process.
     logger.warning(
         "rnti={} h_id={}: Discarding {} HARQ. Cause: Too much time has passed since the last HARQ "
         "transmission. The scheduler policy is likely not prioritizing retransmissions of old HARQ processes.",
         h.rnti,
         h.h_id,
         IsDl ? "DL" : "UL");
     dealloc_harq(h);
+
+    // Report timeout after the HARQ gets deleted to avoid reentrancy.
+    timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, false);
   }
 }
 
@@ -222,9 +225,10 @@ void cell_harq_repository<IsDl>::handle_harq_ack_timeout(harq_type& h, slot_poin
 {
   srsran_sanity_check(h.status == harq_state_t::waiting_ack, "HARQ process in wrong state");
 
+  bool ack_val = h.ack_on_timeout;
   if (not is_ntn_mode()) {
     // Only in non-NTN case, we log a warning.
-    if (h.ack_on_timeout) {
+    if (ack_val) {
       // Case: Not all HARQ-ACKs were received, but at least one positive ACK was received.
       logger.debug("rnti={} h_id={}: Setting {} HARQ to \"ACKed\" state. Cause: HARQ-ACK wait timeout ({} slots) was "
                    "reached with still missing PUCCH HARQ-ACKs. However, one positive ACK was received.",
@@ -242,13 +246,16 @@ void cell_harq_repository<IsDl>::handle_harq_ack_timeout(harq_type& h, slot_poin
                      IsDl ? "DL" : "UL",
                      h.slot_ack_timeout - h.slot_ack);
     }
-
-    // Report timeout with NACK.
-    timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, h.ack_on_timeout);
   }
 
   // Deallocate HARQ.
   dealloc_harq(h);
+
+  if (max_ack_wait_in_slots != 1) {
+    // Report timeout with NACK after we delete the HARQ to avoid reentrancy.
+    // Only in non-NTN case.
+    timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, ack_val);
+  }
 }
 
 template <bool IsDl>
@@ -736,10 +743,11 @@ unique_ue_harq_entity::unique_ue_harq_entity(cell_harq_manager* mgr, du_ue_index
 }
 
 unique_ue_harq_entity::unique_ue_harq_entity(unique_ue_harq_entity&& other) noexcept :
-  cell_harq_mgr(other.cell_harq_mgr), ue_index(other.ue_index)
+  cell_harq_mgr(other.cell_harq_mgr), ue_index(other.ue_index), crnti(other.crnti)
 {
   other.cell_harq_mgr = nullptr;
   other.ue_index      = INVALID_DU_UE_INDEX;
+  other.crnti         = rnti_t::INVALID_RNTI;
 }
 
 unique_ue_harq_entity& unique_ue_harq_entity::operator=(unique_ue_harq_entity&& other) noexcept
@@ -749,8 +757,10 @@ unique_ue_harq_entity& unique_ue_harq_entity::operator=(unique_ue_harq_entity&&
   }
   cell_harq_mgr       = other.cell_harq_mgr;
   ue_index            = other.ue_index;
+  crnti               = other.crnti;
   other.cell_harq_mgr = nullptr;
   other.ue_index      = INVALID_DU_UE_INDEX;
+  other.crnti         = rnti_t::INVALID_RNTI;
   return *this;
 }
 
diff --git a/lib/scheduler/common_scheduling/ra_scheduler.cpp b/lib/scheduler/common_scheduling/ra_scheduler.cpp
@@ -68,6 +68,23 @@ static crb_interval msg3_vrb_to_crb(const cell_configuration& cell_cfg, vrb_inte
                                                   cell_cfg.ul_cfg_common.init_ul_bwp.generic_params.crbs.start());
 }
 
+class ra_scheduler::msg3_harq_timeout_notifier final : public harq_timeout_notifier
+{
+public:
+  msg3_harq_timeout_notifier(std::vector<pending_msg3_t>& pending_msg3s_) : pending_msg3s(pending_msg3s_) {}
+
+  void on_harq_timeout(du_ue_index_t ue_idx, bool is_dl, bool ack) override
+  {
+    srsran_sanity_check(pending_msg3s[ue_idx].busy(), "timeout called but HARQ entity does not exist");
+
+    // Delete Msg3 HARQ entity to make it available again.
+    pending_msg3s[ue_idx].msg3_harq_ent.reset();
+  }
+
+private:
+  std::vector<pending_msg3_t>& pending_msg3s;
+};
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 ra_scheduler::ra_scheduler(const scheduler_ra_expert_config& sched_cfg_,
@@ -87,6 +104,7 @@ ra_scheduler::ra_scheduler(const scheduler_ra_expert_config& sched_cfg_,
                               band_helper::get_duplex_mode(cell_cfg.band),
                               cell_cfg.ul_cfg_common.init_ul_bwp.rach_cfg_common->rach_cfg_generic.prach_config_index)
           .format)),
+  msg3_harqs(MAX_NOF_MSG3, 1, std::make_unique<msg3_harq_timeout_notifier>(pending_msg3s)),
   pending_msg3s(MAX_NOF_MSG3)
 {
   // Precompute RAR PDSCH and DCI PDUs.
@@ -171,8 +189,7 @@ void ra_scheduler::precompute_msg3_pdus()
                            crb_interval{0, prbs_tbs.nof_prbs},
                            i,
                            sched_cfg.msg3_mcs_index,
-                           msg3_rv,
-                           dummy_h_ul);
+                           msg3_rv);
 
     // Note: RNTI will be overwritten later.
     build_pusch_f0_0_tc_rnti(msg3_data[i].pusch,
@@ -246,17 +263,19 @@ void ra_scheduler::handle_rach_indication_impl(const rach_indication_message& ms
                                                             prach_preamble.time_advance.to_Ta(get_ul_bwp_cfg().scs)});
 
       // Check if TC-RNTI value to be scheduled is already under use
-      if (not pending_msg3s[to_value(prach_preamble.tc_rnti) % MAX_NOF_MSG3].harq.empty()) {
+      unsigned msg3_ring_idx = to_value(prach_preamble.tc_rnti) % MAX_NOF_MSG3;
+      auto&    msg3_entry    = pending_msg3s[msg3_ring_idx];
+      if (msg3_entry.busy()) {
         logger.warning("PRACH ignored, as the allocated TC-RNTI={} is already under use", prach_preamble.tc_rnti);
         continue;
       }
 
       // Store TC-RNTI of the preamble.
       rar_req->tc_rntis.emplace_back(prach_preamble.tc_rnti);
 
-      // Store Msg3 to allocate.
-      pending_msg3s[to_value(prach_preamble.tc_rnti) % MAX_NOF_MSG3].preamble = prach_preamble;
-      pending_msg3s[to_value(prach_preamble.tc_rnti) % MAX_NOF_MSG3].msg3_harq_logger.set_rnti(prach_preamble.tc_rnti);
+      // Store Msg3 request and create a HARQ entity of 1 UL HARQ.
+      msg3_entry.preamble      = prach_preamble;
+      msg3_entry.msg3_harq_ent = msg3_harqs.add_ue(to_du_ue_index(msg3_ring_idx), prach_preamble.tc_rnti, 1, 1);
     }
   }
 }
@@ -274,41 +293,51 @@ void ra_scheduler::handle_pending_crc_indications_impl(cell_resource_allocator&
 
   for (const ul_crc_indication& crc_ind : new_crc_inds) {
     for (const ul_crc_pdu_indication& crc : crc_ind.crcs) {
-      srsran_assert(crc.ue_index == INVALID_DU_UE_INDEX, "Msg3 HARQ CRCs cannot have a ueId assigned yet");
+      srsran_assert(crc.ue_index == INVALID_DU_UE_INDEX, "Msg3 HARQ CRCs cannot have a ue index assigned yet");
       auto& pending_msg3 = pending_msg3s[to_value(crc.rnti) % MAX_NOF_MSG3];
-      if (pending_msg3.preamble.tc_rnti != crc.rnti) {
-        logger.warning("Invalid UL CRC, cell={}, rnti={}, h_id={}. Cause: Nonexistent rnti.",
+      if (pending_msg3.preamble.tc_rnti != crc.rnti or pending_msg3.msg3_harq_ent.empty()) {
+        logger.warning("Invalid UL CRC, cell={}, rnti={}, h_id={}. Cause: Nonexistent tc-rnti",
                        cell_cfg.cell_index,
                        crc.rnti,
                        crc.harq_id);
         continue;
       }
-      if (pending_msg3.harq.id != crc.harq_id) {
-        logger.warning("Invalid UL CRC, cell={}, rnti={}, h_id={}. Cause: HARQ-Ids do not match ({} != {})",
+
+      // See TS38.321, 5.4.2.1 - "For UL transmission with UL grant in RA Response, HARQ process identifier 0 is used."
+      harq_id_t                             h_id = to_harq_id(0);
+      std::optional<ul_harq_process_handle> h_ul = pending_msg3.msg3_harq_ent.ul_harq(h_id);
+      if (not h_ul.has_value() or crc.harq_id != h_id) {
+        logger.warning("Invalid UL CRC, cell={}, rnti={}, h_id={}. Cause: HARQ-Id 0 must be used in Msg3",
                        cell_cfg.cell_index,
                        crc.rnti,
-                       crc.harq_id,
-                       crc.harq_id,
-                       pending_msg3.harq.id);
+                       crc.harq_id);
         continue;
       }
-      pending_msg3.harq.crc_info(crc.tb_crc_success);
+
+      // Handle CRC info.
+      h_ul->ul_crc_info(crc.tb_crc_success);
+      if (h_ul->empty()) {
+        // Deallocate Msg3 entry.
+        pending_msg3.msg3_harq_ent.reset();
+      }
     }
   }
 
   // Allocate pending Msg3 retransmissions.
-  for (auto& pending_msg3 : pending_msg3s) {
-    if (not pending_msg3.harq.empty()) {
-      pending_msg3.harq.slot_indication(res_alloc.slot_tx());
-      if (pending_msg3.harq.has_pending_retx()) {
-        schedule_msg3_retx(res_alloc, pending_msg3);
-      }
-    }
+  // Note: pending_ul_retxs size will change in this iteration, so we prefetch the next iterator.
+  auto pending_ul_retxs = msg3_harqs.pending_ul_retxs();
+  for (auto it = pending_ul_retxs.begin(); it != pending_ul_retxs.end();) {
+    ul_harq_process_handle h_ul = *it;
+    ++it;
+    schedule_msg3_retx(res_alloc, pending_msg3s[h_ul.ue_index()]);
   }
 }
 
 void ra_scheduler::run_slot(cell_resource_allocator& res_alloc)
 {
+  // Update Msg3 HARQ state.
+  msg3_harqs.slot_indication(res_alloc.slot_tx());
+
   // Handle pending CRCs, which may lead to Msg3 reTxs.
   handle_pending_crc_indications_impl(res_alloc);
 
@@ -648,10 +677,12 @@ void ra_scheduler::fill_rar_grant(cell_resource_allocator&         res_alloc,
     const vrb_interval            vrbs       = msg3_crb_to_vrb(cell_cfg, msg3_candidate.crbs);
 
     auto& pending_msg3 = pending_msg3s[to_value(rar_request.tc_rntis[i]) % MAX_NOF_MSG3];
-    srsran_sanity_check(pending_msg3.harq.empty(), "Pending Msg3 should not have been added if HARQ is busy");
+    srsran_sanity_check(pending_msg3.busy(), "Pending Msg3 entry should have been reserved when RACH was received");
 
     // Allocate Msg3 UL HARQ
-    pending_msg3.harq.new_tx(msg3_alloc.slot, sched_cfg.max_nof_msg3_harq_retxs);
+    std::optional<ul_harq_process_handle> h_ul =
+        pending_msg3.msg3_harq_ent.alloc_ul_harq(msg3_alloc.slot, sched_cfg.max_nof_msg3_harq_retxs);
+    srsran_sanity_check(h_ul.has_value(), "Pending Msg3 HARQ must be available when RAR is allocated");
 
     // Add MAC SDU with UL grant (Msg3) in RAR PDU.
     rar_ul_grant& msg3_info            = rar.grants.emplace_back();
@@ -683,7 +714,7 @@ void ra_scheduler::fill_rar_grant(cell_resource_allocator&         res_alloc,
     pusch.pusch_cfg.new_data = true;
 
     // Store parameters used in HARQ.
-    pending_msg3.harq.save_alloc_params(ul_harq_sched_context{dci_ul_rnti_config_type::tc_rnti_f0_0}, pusch.pusch_cfg);
+    h_ul->save_grant_params(ul_harq_alloc_context{dci_ul_rnti_config_type::tc_rnti_f0_0}, pusch.pusch_cfg);
   }
 }
 
@@ -703,6 +734,10 @@ void ra_scheduler::schedule_msg3_retx(cell_resource_allocator& res_alloc, pendin
     return;
   }
 
+  ul_harq_process_handle h_ul = msg3_ctx.msg3_harq_ent.ul_harq(to_harq_id(0)).value();
+  srsran_sanity_check(h_ul.has_pending_retx(), "schedule_msg3_retx called when HARQ has no pending reTx");
+  const ul_harq_process_handle::grant_params& last_harq_params = h_ul.get_grant_params();
+
   const span<const pusch_time_domain_resource_allocation> pusch_td_alloc_list =
       get_pusch_time_domain_resource_table(get_pusch_cfg());
   for (unsigned pusch_td_res_index = 0; pusch_td_res_index != pusch_td_alloc_list.size(); ++pusch_td_res_index) {
@@ -713,8 +748,7 @@ void ra_scheduler::schedule_msg3_retx(cell_resource_allocator& res_alloc, pendin
         NOF_OFDM_SYM_PER_SLOT_NORMAL_CP - cell_cfg.get_nof_ul_symbol_per_slot(pusch_alloc.slot);
     // If it is a retx, we need to ensure we use a time_domain_resource with the same number of symbols as used for
     // the first transmission.
-    const bool sym_length_match_prev_grant_for_retx =
-        pusch_td_cfg.symbols.length() == msg3_ctx.harq.last_tx_params().nof_symbols;
+    const bool sym_length_match_prev_grant_for_retx = pusch_td_cfg.symbols.length() == last_harq_params.nof_symbols;
     if (not cell_cfg.is_ul_enabled(pusch_alloc.slot) or pusch_td_cfg.symbols.start() < start_ul_symbols or
         !sym_length_match_prev_grant_for_retx) {
       // Not possible to schedule Msg3s in this TDD slot.
@@ -728,7 +762,7 @@ void ra_scheduler::schedule_msg3_retx(cell_resource_allocator& res_alloc, pendin
     }
 
     // Try to reuse previous HARQ PRBs.
-    const vrb_interval msg3_vrbs = msg3_ctx.harq.last_tx_params().rbs.type1();
+    const vrb_interval msg3_vrbs = last_harq_params.rbs.type1();
     grant_info         grant;
     grant.scs     = bwp_ul_cmn.scs;
     grant.symbols = pusch_td_cfg.symbols;
@@ -764,7 +798,10 @@ void ra_scheduler::schedule_msg3_retx(cell_resource_allocator& res_alloc, pendin
     pusch_alloc.ul_res_grid.fill(grant);
 
     // Allocate new retx in the HARQ.
-    msg3_ctx.harq.new_retx(pusch_alloc.slot);
+    if (not h_ul.new_retx(pusch_alloc.slot)) {
+      logger.warning("tc-rnti={}: Failed to allocate reTx for Msg3", msg3_ctx.preamble.tc_rnti);
+      continue;
+    }
 
     // Fill DCI.
     static constexpr uint8_t msg3_rv = 0;
@@ -773,24 +810,23 @@ void ra_scheduler::schedule_msg3_retx(cell_resource_allocator& res_alloc, pendin
                            cell_cfg.ul_cfg_common.init_ul_bwp.generic_params,
                            grant.crbs,
                            pusch_td_res_index,
-                           msg3_ctx.harq.last_tx_params().mcs,
-                           msg3_rv,
-                           msg3_ctx.harq);
+                           last_harq_params.mcs,
+                           msg3_rv);
 
     // Fill PUSCH.
     ul_sched_info& ul_info     = pusch_alloc.result.ul.puschs.emplace_back();
     ul_info.context.ue_index   = INVALID_DU_UE_INDEX;
     ul_info.context.ss_id      = cell_cfg.dl_cfg_common.init_dl_bwp.pdcch_common.ra_search_space_id;
     ul_info.context.k2         = k2;
-    ul_info.context.nof_retxs  = msg3_ctx.harq.tb().nof_retxs;
+    ul_info.context.nof_retxs  = h_ul.nof_retxs();
     ul_info.pusch_cfg          = msg3_data[pusch_td_res_index].pusch;
     ul_info.pusch_cfg.rnti     = msg3_ctx.preamble.tc_rnti;
     ul_info.pusch_cfg.rbs      = msg3_vrbs;
     ul_info.pusch_cfg.rv_index = pdcch->dci.tc_rnti_f0_0.redundancy_version;
     ul_info.pusch_cfg.new_data = false;
 
     // Store parameters used in HARQ.
-    msg3_ctx.harq.save_alloc_params(ul_harq_sched_context{dci_ul_rnti_config_type::tc_rnti_f0_0}, ul_info.pusch_cfg);
+    h_ul.save_grant_params(ul_harq_alloc_context{dci_ul_rnti_config_type::tc_rnti_f0_0}, ul_info.pusch_cfg);
 
     // successful allocation. Exit loop.
     break;
diff --git a/lib/scheduler/common_scheduling/ra_scheduler.h b/lib/scheduler/common_scheduling/ra_scheduler.h
@@ -10,11 +10,11 @@
 
 #pragma once
 
+#include "../cell/cell_harq_manager.h"
 #include "../cell/resource_grid.h"
 #include "../pdcch_scheduling/pdcch_resource_allocator.h"
 #include "../support/prbs_calculator.h"
 #include "../support/slot_event_list.h"
-#include "../ue_scheduling/harq_process.h"
 #include "srsran/ran/prach/prach_configuration.h"
 #include "srsran/scheduler/config/scheduler_expert_config.h"
 #include "srsran/srslog/srslog.h"
@@ -61,6 +61,8 @@ class ra_scheduler
   void run_slot(cell_resource_allocator& res_alloc);
 
 private:
+  class msg3_harq_timeout_notifier;
+
   struct pending_rar_t {
     rnti_t                                                  ra_rnti = rnti_t::INVALID_RNTI;
     slot_point                                              prach_slot_rx;
@@ -71,11 +73,12 @@ class ra_scheduler
   struct pending_msg3_t {
     /// Detected PRACH Preamble associated to this Msg3.
     rach_indication_message::preamble preamble{};
-    harq_logger msg3_harq_logger{srslog::fetch_basic_logger("SCHED"), rnti_t::INVALID_RNTI, to_du_cell_index(0), false};
     /// UL Harq used to schedule Msg3.
     /// Note: [TS 38.321, 5.4.2.1] "For UL transmission with UL grant in RA Response, HARQ process identifier 0 is
     /// used".
-    ul_harq_process harq{to_harq_id(0), msg3_harq_logger};
+    unique_ue_harq_entity msg3_harq_ent;
+
+    bool busy() const { return not msg3_harq_ent.empty(); }
   };
   struct msg3_alloc_candidate {
     unsigned     pusch_td_res_index;
@@ -170,6 +173,7 @@ class ra_scheduler
   sch_mcs_description                 msg3_mcs_config;
 
   // variables
+  cell_harq_manager                        msg3_harqs;
   slot_event_list<rach_indication_message> pending_rachs;
   slot_event_list<ul_crc_indication>       pending_crcs;
   std::deque<pending_rar_t>                pending_rars;
diff --git a/lib/scheduler/support/dci_builder.cpp b/lib/scheduler/support/dci_builder.cpp
@@ -8,6 +8,8 @@
  */
 
 #include "dci_builder.h"
+#include "../cell/cell_harq_manager.h"
+#include "../ue_scheduling/harq_process.h"
 #include "srsran/adt/optional.h"
 #include "srsran/ran/pdcch/dci_packing.h"
 #include "srsran/ran/pdcch/search_space.h"
@@ -291,12 +293,8 @@ void srsran::build_dci_f0_0_tc_rnti(dci_ul_info&               dci,
                                     const crb_interval&        crbs,
                                     unsigned                   time_resource,
                                     sch_mcs_index              mcs_index,
-                                    uint8_t                    rv,
-                                    const ul_harq_process&     h_ul)
+                                    uint8_t                    rv)
 {
-  // See TS38.321, 5.4.2.1 - "For UL transmission with UL grant in RA Response, HARQ process identifier 0 is used."
-  srsran_assert(h_ul.id == 0, "UL HARQ process used for Msg3 must have id=0");
-
   dci.type                            = dci_ul_rnti_config_type::tc_rnti_f0_0;
   dci.tc_rnti_f0_0                    = {};
   dci_0_0_tc_rnti_configuration& f0_0 = dci.tc_rnti_f0_0;
diff --git a/lib/scheduler/support/dci_builder.h b/lib/scheduler/support/dci_builder.h
@@ -10,14 +10,16 @@
 #pragma once
 
 #include "../config/ue_configuration.h"
-#include "../ue_scheduling/harq_process.h"
 #include "srsran/ran/pdcch/search_space.h"
 #include "srsran/ran/resource_allocation/resource_allocation_frequency.h"
 #include "srsran/scheduler/config/bwp_configuration.h"
 #include "srsran/scheduler/scheduler_dci.h"
 
 namespace srsran {
 
+class dl_harq_process;
+class ul_harq_process;
+
 /// Builds DCI f1_0 for SI-RNTI used in SIBs.
 void build_dci_f1_0_si_rnti(dci_dl_info&               dci,
                             const bwp_downlink_common& init_dl_bwp,
@@ -85,8 +87,7 @@ void build_dci_f0_0_tc_rnti(dci_ul_info&               dci,
                             const crb_interval&        crbs,
                             unsigned                   time_resource,
                             sch_mcs_index              mcs_index,
-                            uint8_t                    rv,
-                            const ul_harq_process&     h_ul);
+                            uint8_t                    rv);
 
 /// Builds DCI f0_0 for C-RNTI.
 void build_dci_f0_0_c_rnti(dci_ul_info&             dci,
diff --git a/lib/scheduler/ue_scheduling/ue_cell_grid_allocator.cpp b/lib/scheduler/ue_scheduling/ue_cell_grid_allocator.cpp

Original file line number	Diff line number	Diff line change
`@@ -206,14 +206,17 @@ void cell_harq_repository<IsDl>::slot_indication(slot_point sl_tx)`
`206`	`206`	`break;`
`207`	`207`	`}`
`208`	`208`
`209`		`- // HARQ is trapped. Remove it.`
	`209`	`+ // HARQ retransmission is trapped. Deallocate HARQ process.`
`210`	`210`	`logger.warning(`
`211`	`211`	`"rnti={} h_id={}: Discarding {} HARQ. Cause: Too much time has passed since the last HARQ "`
`212`	`212`	`"transmission. The scheduler policy is likely not prioritizing retransmissions of old HARQ processes.",`
`213`	`213`	`h.rnti,`
`214`	`214`	`h.h_id,`
`215`	`215`	`IsDl ? "DL" : "UL");`
`216`	`216`	`dealloc_harq(h);`
	`217`	`+`
	`218`	`+ // Report timeout after the HARQ gets deleted to avoid reentrancy.`
	`219`	`+ timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, false);`
`217`	`220`	`}`
`218`	`221`	`}`
`219`	`222`
`@@ -222,9 +225,10 @@ void cell_harq_repository<IsDl>::handle_harq_ack_timeout(harq_type& h, slot_poin`
`222`	`225`	`{`
`223`	`226`	`srsran_sanity_check(h.status == harq_state_t::waiting_ack, "HARQ process in wrong state");`
`224`	`227`
	`228`	`+ bool ack_val = h.ack_on_timeout;`
`225`	`229`	`if (not is_ntn_mode()) {`
`226`	`230`	`// Only in non-NTN case, we log a warning.`
`227`		`- if (h.ack_on_timeout) {`
	`231`	`+ if (ack_val) {`
`228`	`232`	`// Case: Not all HARQ-ACKs were received, but at least one positive ACK was received.`
`229`	`233`	`logger.debug("rnti={} h_id={}: Setting {} HARQ to \"ACKed\" state. Cause: HARQ-ACK wait timeout ({} slots) was "`
`230`	`234`	`"reached with still missing PUCCH HARQ-ACKs. However, one positive ACK was received.",`
`@@ -242,13 +246,16 @@ void cell_harq_repository<IsDl>::handle_harq_ack_timeout(harq_type& h, slot_poin`
`242`	`246`	`IsDl ? "DL" : "UL",`
`243`	`247`	`h.slot_ack_timeout - h.slot_ack);`
`244`	`248`	`}`
`245`		`-`
`246`		`- // Report timeout with NACK.`
`247`		`- timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, h.ack_on_timeout);`
`248`	`249`	`}`
`249`	`250`
`250`	`251`	`// Deallocate HARQ.`
`251`	`252`	`dealloc_harq(h);`
	`253`	`+`
	`254`	`+ if (max_ack_wait_in_slots != 1) {`
	`255`	`+ // Report timeout with NACK after we delete the HARQ to avoid reentrancy.`
	`256`	`+ // Only in non-NTN case.`
	`257`	`+ timeout_notifier.on_harq_timeout(h.ue_idx, IsDl, ack_val);`
	`258`	`+ }`
`252`	`259`	`}`
`253`	`260`
`254`	`261`	`template <bool IsDl>`
`@@ -736,10 +743,11 @@ unique_ue_harq_entity::unique_ue_harq_entity(cell_harq_manager* mgr, du_ue_index`
`736`	`743`	`}`
`737`	`744`
`738`	`745`	`unique_ue_harq_entity::unique_ue_harq_entity(unique_ue_harq_entity&& other) noexcept :`
`739`		`- cell_harq_mgr(other.cell_harq_mgr), ue_index(other.ue_index)`
	`746`	`+ cell_harq_mgr(other.cell_harq_mgr), ue_index(other.ue_index), crnti(other.crnti)`
`740`	`747`	`{`
`741`	`748`	`other.cell_harq_mgr = nullptr;`
`742`	`749`	`other.ue_index = INVALID_DU_UE_INDEX;`
	`750`	`+ other.crnti = rnti_t::INVALID_RNTI;`
`743`	`751`	`}`
`744`	`752`
`745`	`753`	`unique_ue_harq_entity& unique_ue_harq_entity::operator=(unique_ue_harq_entity&& other) noexcept`
`@@ -749,8 +757,10 @@ unique_ue_harq_entity& unique_ue_harq_entity::operator=(unique_ue_harq_entity&&`
`749`	`757`	`}`
`750`	`758`	`cell_harq_mgr = other.cell_harq_mgr;`
`751`	`759`	`ue_index = other.ue_index;`
	`760`	`+ crnti = other.crnti;`
`752`	`761`	`other.cell_harq_mgr = nullptr;`
`753`	`762`	`other.ue_index = INVALID_DU_UE_INDEX;`
	`763`	`+ other.crnti = rnti_t::INVALID_RNTI;`
`754`	`764`	`return *this;`
`755`	`765`	`}`
`756`	`766`