sched: pending HARQ retxs are now ordered based on time of ACK arrival

Author: frankist

include/srsran/adt/intrusive_list.h

@@ -137,7 +137,7 @@ class intrusive_double_linked_list
   template <typename U>
   class iterator_impl
   {
-    using elem_t = typename std::conditional<std::is_const<U>::value, const node_t, node_t>::type;
+    using elem_t = std::conditional_t<std::is_const<U>::value, const node_t, node_t>;
 
   public:
     using iterator_category = std::bidirectional_iterator_tag;
@@ -173,24 +173,28 @@ class intrusive_double_linked_list
 
   intrusive_double_linked_list()
   {
-    static_assert(std::is_base_of<node_t, T>::value,
+    static_assert(std::is_base_of_v<node_t, T>,
                   "Provided template argument T must have intrusive_forward_list_element<Tag> as base class");
   }
   intrusive_double_linked_list(const intrusive_double_linked_list&) = default;
-  intrusive_double_linked_list(intrusive_double_linked_list&& other) noexcept : node(other.node)
+  intrusive_double_linked_list(intrusive_double_linked_list&& other) noexcept : node(other.node), tail(other.tail)
   {
     other.node = nullptr;
+    other.tail = nullptr;
   }
   intrusive_double_linked_list& operator=(const intrusive_double_linked_list&) = default;
   intrusive_double_linked_list& operator=(intrusive_double_linked_list&& other) noexcept
   {
     node       = other.node;
+    tail       = other.tail;
     other.node = nullptr;
+    other.tail = nullptr;
     return *this;
   }
   ~intrusive_double_linked_list() { clear(); }
 
   T& front() const { return *static_cast<T*>(node); }
+  T& back() const { return *static_cast<T*>(tail); }
 
   void push_front(T* t)
   {
@@ -199,15 +203,36 @@ class intrusive_double_linked_list
     new_head->next_node = node;
     if (node != nullptr) {
       node->prev_node = new_head;
+    } else {
+      tail = new_head;
     }
     node = new_head;
   }
 
+  void push_back(T* t)
+  {
+    node_t* new_tail    = static_cast<node_t*>(t);
+    new_tail->prev_node = tail;
+    new_tail->next_node = nullptr;
+    if (tail != nullptr) {
+      tail->next_node = new_tail;
+    } else {
+      node = new_tail;
+    }
+    tail = new_tail;
+  }
+
   void pop(T* t)
   {
     node_t* to_rem = static_cast<node_t*>(t);
     if (to_rem == node) {
       node = to_rem->next_node;
+      if (node == nullptr) {
+        tail = nullptr;
+      }
+    } else if (to_rem == tail) {
+      tail = to_rem->prev_node;
+      // tail==head checked in first if condition.
     }
     if (to_rem->prev_node != nullptr) {
       to_rem->prev_node->next_node = to_rem->next_node;
@@ -218,7 +243,11 @@ class intrusive_double_linked_list
     to_rem->next_node = nullptr;
     to_rem->prev_node = nullptr;
   }
+
   void pop_front() { pop(static_cast<T*>(node)); }
+
+  void pop_back() { pop(static_cast<T*>(tail)); }
+
   void clear()
   {
     while (node != nullptr) {
@@ -227,6 +256,7 @@ class intrusive_double_linked_list
       torem->next_node = nullptr;
       torem->prev_node = nullptr;
     }
+    tail = nullptr;
   }
 
   bool empty() const { return node == nullptr; }
@@ -238,6 +268,7 @@ class intrusive_double_linked_list
 
 private:
   node_t* node = nullptr;
+  node_t* tail = nullptr;
 };
 
 } // namespace srsran

lib/scheduler/ue_scheduling/cell_harq_manager.cpp

@@ -217,7 +217,7 @@ void cell_harq_repository<IsDl>::set_pending_retx(harq_type& h)
   harq_timeout_wheel[h.slot_ack_timeout.to_uint() % harq_timeout_wheel.size()].pop(&h);
 
   // Add HARQ to pending Retx list.
-  harq_pending_retx_list.push_front(&h);
+  harq_pending_retx_list.push_back(&h);
 
   // Update HARQ process state.
   h.status = harq_state_t::pending_retx;

tests/unittests/scheduler/ue_scheduling/harq_manager_test.cpp

@@ -936,3 +936,35 @@ TEST_F(multi_ue_harq_manager_test, when_harq_entities_are_nacked_then_they_appea
   }
   ASSERT_EQ(count, 1);
 }
+
+TEST_F(multi_ue_harq_manager_test, pending_harq_retxs_are_ordered_from_oldest_to_newest_ack)
+{
+  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(harq_ent1.alloc_dl_harq(current_slot, k1, max_retxs, 0).has_value());
+  ASSERT_TRUE(harq_ent2.alloc_ul_harq(current_slot + k2, max_retxs).has_value());
+  ASSERT_TRUE(harq_ent2.alloc_dl_harq(current_slot, k1, max_retxs, 0).has_value());
+  ASSERT_TRUE(harq_ent1.alloc_ul_harq(current_slot + k2, max_retxs).has_value());
+
+  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_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);
+  ASSERT_EQ(harq_ent1.find_ul_harq(current_slot + k2)->ul_crc_info(false), 0);
+
+  unsigned count = 0;
+  for (dl_harq_process_handle h : cell_harqs.pending_dl_retxs()) {
+    ASSERT_EQ(h.rnti(), to_rnti(0x4601 + count));
+    count++;
+  }
+  ASSERT_EQ(count, 2);
+  count = 0;
+  for (ul_harq_process_handle h : cell_harqs.pending_ul_retxs()) {
+    ASSERT_EQ(h.rnti(), to_rnti(0x4602 - count));
+    count++;
+  }
+  ASSERT_EQ(count, 2);
+}