sched: wrote basic unit test for harq manager

Author: frankist

lib/scheduler/ue_scheduling/cell_harq_manager.cpp

@@ -32,6 +32,9 @@ cell_harq_repository<IsDl>::cell_harq_repository(unsigned               max_ues,
     ues[i].free_harq_ids.reserve(MAX_NOF_HARQS);
     ues[i].harqs.resize(MAX_NOF_HARQS, INVALID_HARQ_REF_INDEX);
   }
+
+  const unsigned RING_SIZE = 40; // TODO: use function to define this value.
+  harq_timeout_wheel.resize(RING_SIZE);
 }
 
 template <bool IsDl>
@@ -240,7 +243,7 @@ unsigned cell_harq_repository<IsDl>::find_ue_harq_in_state(du_ue_index_t ue_idx,
   for (unsigned h_ref_idx : ues[ue_idx].harqs) {
     if (h_ref_idx != INVALID_HARQ_REF_INDEX) {
       const harq_type& h = harqs[h_ref_idx];
-      if (h.status == harq_state_t::pending_retx) {
+      if (h.status == state) {
         return h_ref_idx;
       }
     }
@@ -254,8 +257,8 @@ template struct harq_utils::cell_harq_repository<false>;
 // Cell HARQ manager.
 
 cell_harq_manager::cell_harq_manager(unsigned                               max_ues,
-                                     unsigned                               max_ack_wait_timeout,
-                                     std::unique_ptr<harq_timeout_notifier> notifier) :
+                                     std::unique_ptr<harq_timeout_notifier> notifier,
+                                     unsigned                               max_ack_wait_timeout) :
   timeout_notifier(std::move(notifier)),
   logger(srslog::fetch_basic_logger("SCHED")),
   dl(max_ues, max_ack_wait_timeout, *timeout_notifier, logger),
@@ -403,7 +406,9 @@ unique_ue_harq_entity::unique_ue_harq_entity(unique_ue_harq_entity&& other) noex
 
 unique_ue_harq_entity& unique_ue_harq_entity::operator=(unique_ue_harq_entity&& other) noexcept
 {
-  cell_harq_mgr->destroy_ue(ue_index);
+  if (cell_harq_mgr != nullptr) {
+    cell_harq_mgr->destroy_ue(ue_index);
+  }
   cell_harq_mgr       = other.cell_harq_mgr;
   ue_index            = other.ue_index;
   other.cell_harq_mgr = nullptr;
@@ -418,6 +423,14 @@ unique_ue_harq_entity::~unique_ue_harq_entity()
   }
 }
 
+void unique_ue_harq_entity::reset()
+{
+  if (cell_harq_mgr != nullptr) {
+    cell_harq_mgr->destroy_ue(ue_index);
+    cell_harq_mgr = nullptr;
+  }
+}
+
 std::optional<dl_harq_process_view>
 unique_ue_harq_entity::alloc_dl_harq(slot_point sl_tx, unsigned k1, unsigned max_harq_nof_retxs, unsigned harq_bit_idx)
 {

lib/scheduler/ue_scheduling/cell_harq_manager.h

@@ -36,6 +36,14 @@ class harq_timeout_notifier
   virtual void on_harq_timeout(du_ue_index_t ue_idx, bool is_dl, bool ack) = 0;
 };
 
+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 */
+  }
+};
+
 namespace harq_utils {
 
 const static unsigned INVALID_HARQ_REF_INDEX = std::numeric_limits<unsigned>::max();
@@ -156,7 +164,13 @@ struct cell_harq_repository {
 class cell_harq_manager
 {
 public:
-  cell_harq_manager(unsigned max_ues, unsigned max_ack_wait_timeout, std::unique_ptr<harq_timeout_notifier> notifier);
+  /// \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 = std::make_unique<noop_harq_timeout_notifier>(),
+                    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);
@@ -168,8 +182,10 @@ class cell_harq_manager
   /// 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, unsigned nof_ul_harq_procs);
+  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;
@@ -223,6 +239,17 @@ class dl_harq_process_view
   dl_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->dl.harqs[harq_ref_idx].status != harq_utils::harq_state_t::empty,
+                        "Empty HARQ process created");
+  }
+
+  bool is_waiting_ack() 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;
   }
 
   /// \brief Update the state of the DL HARQ process waiting for an HARQ-ACK.
@@ -233,6 +260,12 @@ class dl_harq_process_view
 
   const grant_params& get_grant_params() const { return cell_harq_mng->dl.harqs[harq_ref_idx].prev_tx_params; }
 
+  bool operator==(const dl_harq_process_view& other) const
+  {
+    return cell_harq_mng == other.cell_harq_mng and harq_ref_idx == other.harq_ref_idx;
+  }
+  bool operator!=(const dl_harq_process_view& other) const { return !(*this == other); }
+
 private:
   cell_harq_manager* cell_harq_mng = nullptr;
   unsigned           harq_ref_idx  = cell_harq_manager::INVALID_HARQ;
@@ -244,12 +277,29 @@ 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");
+  }
+
+  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;
   }
 
   /// 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);
 
+  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:
   cell_harq_manager* cell_harq_mng = nullptr;
   unsigned           harq_ref_idx  = cell_harq_manager::INVALID_HARQ;
@@ -258,9 +308,11 @@ class ul_harq_process_view
 class unique_ue_harq_entity
 {
 public:
+  unique_ue_harq_entity() = default;
   unique_ue_harq_entity(cell_harq_manager* mgr, du_ue_index_t ue_idx, rnti_t crnti_) :
     cell_harq_mgr(mgr), ue_index(ue_idx), crnti(crnti_)
   {
+    (void)crnti;
   }
   ~unique_ue_harq_entity();
   unique_ue_harq_entity(const unique_ue_harq_entity&) = delete;
@@ -274,6 +326,8 @@ class unique_ue_harq_entity
   bool has_empty_dl_harqs() const { return not get_dl_ue().free_harq_ids.empty(); }
   bool has_empty_ul_harqs() const { return not get_ul_ue().free_harq_ids.empty(); }
 
+  void reset();
+
   std::optional<dl_harq_process_view> dl_harq(harq_id_t h_id)
   {
     if (cell_harq_mgr->dl.ues[ue_index].harqs[h_id] != harq_utils::INVALID_HARQ_REF_INDEX) {
@@ -318,7 +372,7 @@ class unique_ue_harq_entity
 
   cell_harq_manager* cell_harq_mgr = nullptr;
   du_ue_index_t      ue_index      = INVALID_DU_UE_INDEX;
-  rnti_t             crnti;
+  rnti_t             crnti         = rnti_t::INVALID_RNTI;
 };
 
 } // namespace srsran

tests/unittests/scheduler/ue_scheduling/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 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

tests/unittests/scheduler/ue_scheduling/harq_manager_test.cpp

@@ -0,0 +1,69 @@
+/*
+ *
+ * Copyright 2021-2024 Software Radio Systems Limited
+ *
+ * By using this file, you agree to the terms and conditions set
+ * forth in the LICENSE file which can be found at the top level of
+ * the distribution.
+ *
+ */
+
+#include "lib/scheduler/ue_scheduling/cell_harq_manager.h"
+#include "srsran/support/test_utils.h"
+#include <gtest/gtest.h>
+
+using namespace srsran;
+
+class harq_entity_test : public ::testing::Test
+{
+protected:
+  cell_harq_manager cell_harqs{1};
+  du_ue_index_t     ue_index  = to_du_ue_index(0);
+  rnti_t            rnti      = to_rnti(0x4601);
+  unsigned          max_retxs = 4;
+
+  unique_ue_harq_entity harq_ent;
+};
+
+TEST_F(harq_entity_test, when_ue_harq_entity_is_created_cell_harq_manager_is_updated)
+{
+  ASSERT_FALSE(cell_harqs.contains(ue_index));
+  harq_ent = cell_harqs.add_ue(ue_index, rnti, 16, 16);
+  ASSERT_TRUE(cell_harqs.contains(ue_index));
+  harq_ent.reset();
+  ASSERT_FALSE(cell_harqs.contains(ue_index));
+}
+
+TEST_F(harq_entity_test, when_harq_entity_is_created_all_harqs_are_empty)
+{
+  harq_ent = cell_harqs.add_ue(ue_index, rnti, 16, 16);
+  ASSERT_EQ(harq_ent.nof_dl_harqs(), 16);
+  ASSERT_EQ(harq_ent.nof_ul_harqs(), 16);
+  ASSERT_EQ(harq_ent.find_dl_harq_waiting_ack(), std::nullopt);
+  ASSERT_EQ(harq_ent.find_pending_dl_retx(), std::nullopt);
+  ASSERT_EQ(harq_ent.find_ul_harq_waiting_ack(), std::nullopt);
+  ASSERT_EQ(harq_ent.find_pending_ul_retx(), std::nullopt);
+  ASSERT_TRUE(harq_ent.has_empty_dl_harqs());
+  ASSERT_TRUE(harq_ent.has_empty_ul_harqs());
+  for (unsigned i = 0; i != 16; ++i) {
+    ASSERT_FALSE(harq_ent.dl_harq(to_harq_id(i)).has_value());
+    ASSERT_FALSE(harq_ent.ul_harq(to_harq_id(i)).has_value());
+  }
+}
+
+TEST_F(harq_entity_test, when_harq_is_allocated_then_it_enters_waiting_ack_state)
+{
+  harq_ent = cell_harqs.add_ue(ue_index, rnti, 16, 16);
+  slot_point            sl_tx{0, 0};
+  unsigned              k1   = 4;
+  auto                  h_dl = harq_ent.alloc_dl_harq(sl_tx, k1, max_retxs, 0);
+  ASSERT_TRUE(h_dl.has_value());
+  ASSERT_TRUE(h_dl.value().is_waiting_ack());
+  ASSERT_FALSE(h_dl.value().has_pending_retx());
+  ASSERT_EQ(harq_ent.find_dl_harq_waiting_ack(), h_dl);
+  auto h_ul = harq_ent.alloc_ul_harq(sl_tx, max_retxs);
+  ASSERT_TRUE(h_ul.has_value());
+  ASSERT_TRUE(h_ul.value().is_waiting_ack());
+  ASSERT_FALSE(h_ul.value().has_pending_retx());
+  ASSERT_EQ(harq_ent.find_ul_harq_waiting_ack(), h_ul);
+}