sched: implementation of view of pending HARQ retxs

Author: frankist

lib/scheduler/ue_scheduling/cell_harq_manager.cpp

@@ -330,6 +330,16 @@ bool cell_harq_manager::contains(du_ue_index_t ue_idx) const
   return ue_idx < dl.ues.size() and dl.ues[ue_idx].free_harq_ids.size() != 0;
 }
 
+dl_harq_pending_retx_list cell_harq_manager::pending_dl_retxs()
+{
+  return dl_harq_pending_retx_list{dl};
+}
+
+ul_harq_pending_retx_list cell_harq_manager::pending_ul_retxs()
+{
+  return ul_harq_pending_retx_list{ul};
+}
+
 unique_ue_harq_entity
 cell_harq_manager::add_ue(du_ue_index_t ue_idx, rnti_t crnti, unsigned nof_dl_harq_procs, unsigned nof_ul_harq_procs)
 {

lib/scheduler/ue_scheduling/cell_harq_manager.h

@@ -173,13 +173,15 @@ class base_harq_process_handle
   using harq_impl_type = std::conditional_t<IsDl, dl_harq_process_impl, ul_harq_process_impl>;
 
 public:
+  base_harq_process_handle() = default;
   base_harq_process_handle(harq_pool& pool_, unsigned harq_ref_idx_) : harq_repo(&pool_), harq_ref_idx(harq_ref_idx_)
   {
     srsran_sanity_check(harq_ref_idx < harq_repo->harqs.size(), "Invalid HARQ created");
     srsran_sanity_check(harq_repo->harqs[harq_ref_idx].status != harq_utils::harq_state_t::empty,
                         "Empty HARQ process created");
   }
 
+  rnti_t    rnti() const { return fetch_impl().rnti; }
   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; }
@@ -227,61 +229,6 @@ struct ul_harq_sched_context {
   std::optional<ran_slice_id_t> slice_id;
 };
 
-class cell_harq_manager
-{
-public:
-  /// \brief Default timeout in slots after which the HARQ process assumes that the CRC/ACK went missing
-  /// (implementation-defined).
-  constexpr static unsigned DEFAULT_ACK_TIMEOUT_SLOTS = 256U;
-
-  cell_harq_manager(unsigned                               max_ues              = MAX_NOF_DU_UES,
-                    std::unique_ptr<harq_timeout_notifier> notifier             = nullptr,
-                    unsigned                               max_ack_wait_timeout = DEFAULT_ACK_TIMEOUT_SLOTS);
-
-  /// Update slot, and checks if there are HARQ processes that have reached maxReTx with no ACK
-  void slot_indication(slot_point sl_tx);
-
-  /// Create new UE HARQ entity.
-  /// \param rnti RNTI of the UE
-  /// \param nof_dl_harq_procs Number of DL HARQ processes that the UE can support. This value is derived based on
-  /// the UE capabilities, and passed to the UE via RRC signalling. See TS38.331, "nrofHARQ-ProcessesForPDSCH".
-  /// Values: {2, 4, 6, 10, 12, 16}.
-  /// \param nof_ul_harq_procs Number of UL HARQ processes that gNB can support. This value is implementation-defined
-  /// and can up to 16 (there are up to 4 bits for HARQ-Id signalling).
-  unique_ue_harq_entity add_ue(du_ue_index_t ue_idx,
-                               rnti_t        crnti,
-                               unsigned      nof_dl_harq_procs = MAX_NOF_HARQS,
-                               unsigned      nof_ul_harq_procs = MAX_NOF_HARQS);
-
-  /// Checks whether an UE with the provided ue index exists.
-  bool contains(du_ue_index_t ue_idx) const;
-
-private:
-  friend class unique_ue_harq_entity;
-
-  void destroy_ue(du_ue_index_t ue_idx);
-
-  /// \brief Called on every DL new Tx to allocate an DL HARQ process.
-  harq_utils::dl_harq_process_impl* new_dl_tx(du_ue_index_t ue_idx,
-                                              rnti_t        rnti,
-                                              slot_point    pdsch_slot,
-                                              unsigned      k1,
-                                              unsigned      max_harq_nof_retxs,
-                                              uint8_t       harq_bit_idx);
-
-  /// \brief Called on every UL new Tx to allocate an UL HARQ process.
-  harq_utils::ul_harq_process_impl*
-  new_ul_tx(du_ue_index_t ue_idx, rnti_t rnti, slot_point pusch_slot, unsigned max_harq_nof_retxs);
-
-  std::unique_ptr<harq_timeout_notifier> timeout_notifier;
-  srslog::basic_logger&                  logger;
-
-  slot_point last_sl_tx;
-
-  harq_utils::cell_harq_repository<true>  dl;
-  harq_utils::cell_harq_repository<false> ul;
-};
-
 /// \brief Interface used to fetch and update the status of a DL HARQ process.
 /// \remark This handle acts like a view to an internal HARQ process. It is not a "unique" type that controls the
 /// lifetime of a HARQ. Avoid storing and using the same handle across different slots.
@@ -297,10 +244,7 @@ class dl_harq_process_handle : public harq_utils::base_harq_process_handle<true>
   using status_update = harq_utils::dl_harq_process_impl::status_update;
   using grant_params  = harq_utils::dl_harq_process_impl::alloc_params;
 
-  dl_harq_process_handle(harq_utils::cell_harq_repository<true>& harq_repo_, unsigned h_ref_idx_) :
-    base_type(harq_repo_, h_ref_idx_)
-  {
-  }
+  using base_type::base_type;
 
   using base_type::empty;
   using base_type::has_pending_retx;
@@ -341,7 +285,7 @@ class ul_harq_process_handle : public harq_utils::base_harq_process_handle<false
   using base_type = harq_utils::base_harq_process_handle<false>;
 
 public:
-  ul_harq_process_handle(harq_pool& harq_repo_, unsigned h_ref_idx) : base_type(harq_repo_, h_ref_idx) {}
+  using base_type::base_type;
 
   using base_type::empty;
   using base_type::has_pending_retx;
@@ -367,6 +311,124 @@ class ul_harq_process_handle : public harq_utils::base_harq_process_handle<false
   slot_point pusch_slot() const { return fetch_impl().slot_tx; }
 };
 
+namespace harq_utils {
+
+template <bool IsDl>
+class harq_pending_retx_list_impl
+{
+  using harq_pool      = harq_utils::cell_harq_repository<IsDl>;
+  using harq_impl_type = std::conditional_t<IsDl, harq_utils::dl_harq_process_impl, harq_utils::ul_harq_process_impl>;
+  using handle_type    = std::conditional_t<IsDl, dl_harq_process_handle, ul_harq_process_handle>;
+
+public:
+  struct iterator {
+    using value_type        = handle_type;
+    using reference         = handle_type;
+    using pointer           = std::optional<value_type>;
+    using iterator_category = std::forward_iterator_tag;
+
+    iterator(harq_pool& pool_, typename intrusive_double_linked_list<harq_impl_type>::iterator it_) :
+      pool(&pool_), it(it_)
+    {
+    }
+
+    reference operator++()
+    {
+      ++it;
+      return value();
+    }
+    reference operator*() { return value(); }
+    reference value()
+    {
+      return it != pool->harq_pending_retx_list.end() ? handle_type{*pool, get_harq_ref_idx(*it)} : handle_type{};
+    }
+
+    bool operator==(const iterator& other) const { return pool == other.pool and it == other.it; }
+    bool operator!=(const iterator& other) const { return !(*this == other); }
+
+  private:
+    unsigned get_harq_ref_idx(const harq_impl_type& h) { return &h - pool->harqs.data(); }
+
+    harq_pool*                                                      pool;
+    typename intrusive_double_linked_list<harq_impl_type>::iterator it;
+  };
+
+  explicit harq_pending_retx_list_impl(harq_pool& pool_) : pool(&pool_) {}
+
+  bool empty() const { return pool->harq_pending_retx_list.empty(); }
+
+  iterator begin() { return iterator{*pool, pool->harq_pending_retx_list.begin()}; }
+  iterator end() { return iterator{*pool, pool->harq_pending_retx_list.end()}; }
+
+private:
+  harq_pool* pool;
+};
+
+} // namespace harq_utils
+
+using dl_harq_pending_retx_list = harq_utils::harq_pending_retx_list_impl<true>;
+using ul_harq_pending_retx_list = harq_utils::harq_pending_retx_list_impl<false>;
+
+/// Manager of all HARQ processes in a given cell.
+class cell_harq_manager
+{
+public:
+  /// \brief Default timeout in slots after which the HARQ process assumes that the CRC/ACK went missing
+  /// (implementation-defined).
+  constexpr static unsigned DEFAULT_ACK_TIMEOUT_SLOTS = 256U;
+
+  cell_harq_manager(unsigned                               max_ues              = MAX_NOF_DU_UES,
+                    std::unique_ptr<harq_timeout_notifier> notifier             = nullptr,
+                    unsigned                               max_ack_wait_timeout = DEFAULT_ACK_TIMEOUT_SLOTS);
+
+  /// Update slot, and checks if there are HARQ processes that have reached maxReTx with no ACK
+  void slot_indication(slot_point sl_tx);
+
+  /// Create new UE HARQ entity.
+  /// \param rnti RNTI of the UE
+  /// \param nof_dl_harq_procs Number of DL HARQ processes that the UE can support. This value is derived based on
+  /// the UE capabilities, and passed to the UE via RRC signalling. See TS38.331, "nrofHARQ-ProcessesForPDSCH".
+  /// Values: {2, 4, 6, 10, 12, 16}.
+  /// \param nof_ul_harq_procs Number of UL HARQ processes that gNB can support. This value is implementation-defined
+  /// and can up to 16 (there are up to 4 bits for HARQ-Id signalling).
+  unique_ue_harq_entity add_ue(du_ue_index_t ue_idx,
+                               rnti_t        crnti,
+                               unsigned      nof_dl_harq_procs = MAX_NOF_HARQS,
+                               unsigned      nof_ul_harq_procs = MAX_NOF_HARQS);
+
+  /// Checks whether an UE with the provided ue index exists.
+  bool contains(du_ue_index_t ue_idx) const;
+
+  /// Retrieve list of HARQ processes with pending retxs.
+  dl_harq_pending_retx_list pending_dl_retxs();
+  ul_harq_pending_retx_list pending_ul_retxs();
+
+private:
+  friend class unique_ue_harq_entity;
+
+  void destroy_ue(du_ue_index_t ue_idx);
+
+  /// \brief Called on every DL new Tx to allocate an DL HARQ process.
+  harq_utils::dl_harq_process_impl* new_dl_tx(du_ue_index_t ue_idx,
+                                              rnti_t        rnti,
+                                              slot_point    pdsch_slot,
+                                              unsigned      k1,
+                                              unsigned      max_harq_nof_retxs,
+                                              uint8_t       harq_bit_idx);
+
+  /// \brief Called on every UL new Tx to allocate an UL HARQ process.
+  harq_utils::ul_harq_process_impl*
+  new_ul_tx(du_ue_index_t ue_idx, rnti_t rnti, slot_point pusch_slot, unsigned max_harq_nof_retxs);
+
+  std::unique_ptr<harq_timeout_notifier> timeout_notifier;
+  srslog::basic_logger&                  logger;
+
+  slot_point last_sl_tx;
+
+  harq_utils::cell_harq_repository<true>  dl;
+  harq_utils::cell_harq_repository<false> ul;
+};
+
 class unique_ue_harq_entity
 {
 public:

tests/unittests/scheduler/ue_scheduling/harq_manager_test.cpp

@@ -877,3 +877,62 @@ TEST_F(multi_ue_harq_manager_test, when_harq_entities_are_destroyed_then_pending
   run_slot();
   ASSERT_EQ(this->timeout_handler.last_ue_index, to_du_ue_index(2));
 }
+
+TEST_F(multi_ue_harq_manager_test, when_harq_entities_are_nacked_then_they_appear_in_list_of_harqs_with_pending_retxs)
+{
+  const unsigned        k1 = 4, k2 = 6, max_retxs = 4;
+  unique_ue_harq_entity harq_ent1 = cell_harqs.add_ue(to_du_ue_index(1), to_rnti(0x4601), nof_harqs, nof_harqs);
+  unique_ue_harq_entity harq_ent2 = cell_harqs.add_ue(to_du_ue_index(2), to_rnti(0x4602), nof_harqs, nof_harqs);
+
+  ASSERT_TRUE(cell_harqs.pending_dl_retxs().empty());
+  ASSERT_TRUE(cell_harqs.pending_ul_retxs().empty());
+
+  auto h_dl1 = harq_ent1.alloc_dl_harq(current_slot, k1, max_retxs, 0);
+  auto h_dl2 = harq_ent2.alloc_dl_harq(current_slot, k1, max_retxs, 0);
+  auto h_ul1 = harq_ent1.alloc_ul_harq(current_slot + k2, max_retxs);
+  auto h_ul2 = harq_ent2.alloc_ul_harq(current_slot + k2, max_retxs);
+  ASSERT_TRUE(h_dl1.has_value() and h_dl2.has_value() and h_ul1.has_value() and h_ul2.has_value());
+
+  ASSERT_TRUE(cell_harqs.pending_dl_retxs().empty());
+  ASSERT_TRUE(cell_harqs.pending_ul_retxs().empty());
+  ASSERT_EQ(cell_harqs.pending_dl_retxs().begin(), cell_harqs.pending_dl_retxs().end());
+
+  ASSERT_EQ(harq_ent1.find_dl_harq(current_slot + k1, 0)->dl_ack_info(mac_harq_ack_report_status::nack, std::nullopt),
+            dl_harq_process_handle::status_update::nacked);
+  ASSERT_EQ(harq_ent1.find_ul_harq(current_slot + k2)->ul_crc_info(false), 0);
+  ASSERT_EQ(harq_ent2.find_dl_harq(current_slot + k1, 0)->dl_ack_info(mac_harq_ack_report_status::nack, std::nullopt),
+            dl_harq_process_handle::status_update::nacked);
+  ASSERT_EQ(harq_ent2.find_ul_harq(current_slot + k2)->ul_crc_info(false), 0);
+
+  // HARQs are in the list of pending retxs.
+  ASSERT_FALSE(cell_harqs.pending_dl_retxs().empty());
+  ASSERT_FALSE(cell_harqs.pending_ul_retxs().empty());
+  ASSERT_NE(cell_harqs.pending_dl_retxs().begin(), cell_harqs.pending_dl_retxs().end());
+  unsigned count = 0;
+  for (dl_harq_process_handle h : cell_harqs.pending_dl_retxs()) {
+    ASSERT_TRUE(h.has_pending_retx());
+    count++;
+  }
+  ASSERT_EQ(count, 2);
+  count = 0;
+  for (ul_harq_process_handle h : cell_harqs.pending_ul_retxs()) {
+    ASSERT_TRUE(h.has_pending_retx());
+    count++;
+  }
+
+  // If we cancel the HARQ, it should not show up in the list of pending reTx.
+  h_dl2->cancel_retxs();
+  h_ul1->cancel_retxs();
+  count = 0;
+  for (dl_harq_process_handle h : cell_harqs.pending_dl_retxs()) {
+    ASSERT_EQ(h.rnti(), to_rnti(0x4601));
+    count++;
+  }
+  ASSERT_EQ(count, 1);
+  count = 0;
+  for (ul_harq_process_handle h : cell_harqs.pending_ul_retxs()) {
+    ASSERT_EQ(h.rnti(), to_rnti(0x4602));
+    count++;
+  }
+  ASSERT_EQ(count, 1);
+}