f1u,du: avoid redundant DSSS on expired ul_notif_timer

Author: robertfalkenberg

lib/f1u/du/f1u_bearer_impl.cpp

@@ -59,7 +59,7 @@ void f1u_bearer_impl::handle_sdu(byte_buffer_chain sdu)
   // attach the SDU
   msg.t_pdu = std::move(sdu);
 
-  // attach data delivery status (if anything has changed)
+  // piggy-back latest data delivery status (ignore if anything has changed)
   fill_data_delivery_status(msg);
 
   if (buffering) {
@@ -107,7 +107,7 @@ void f1u_bearer_impl::handle_pdu_impl(nru_dl_message msg)
   }
   // handle polling of delivery status report
   if (msg.dl_user_data.report_polling) {
-    if (send_data_delivery_status()) {
+    if (send_data_delivery_status(/* force = */ true)) {
       logger.log_debug("Report polling flag is set. Sent data delivery status");
     } else {
       logger.log_warning("Report polling flag is set. No data to be sent in data delivery status");
@@ -192,9 +192,13 @@ bool f1u_bearer_impl::fill_highest_transmitted_pdcp_sn(nru_dl_data_delivery_stat
   // In case the DL DATA DELIVERY STATUS frame is sent before any NR PDCP PDU is transferred to lower layers, the
   // information on the highest NR PDCP PDU sequence number successfully delivered in sequence to the UE and the
   // highest NR PDCP PDU sequence number transmitted to the lower layers may not be provided.
-  if (cur_highest_transmitted_pdcp_sn != unset_pdcp_sn) {
-    logger.log_debug("Adding highest transmitted pdcp_sn={}", cur_highest_transmitted_pdcp_sn);
-    status.highest_transmitted_pdcp_sn = cur_highest_transmitted_pdcp_sn;
+  if (cur_highest_transmitted_pdcp_sn == unset_pdcp_sn) {
+    return false;
+  }
+  logger.log_debug("Adding highest transmitted pdcp_sn={}", cur_highest_transmitted_pdcp_sn);
+  status.highest_transmitted_pdcp_sn = cur_highest_transmitted_pdcp_sn;
+  if (cur_highest_transmitted_pdcp_sn != notif_highest_transmitted_pdcp_sn) {
+    notif_highest_transmitted_pdcp_sn = cur_highest_transmitted_pdcp_sn;
     return true;
   }
   return false;
@@ -214,9 +218,13 @@ bool f1u_bearer_impl::fill_highest_delivered_pdcp_sn(nru_dl_data_delivery_status
   // In case the DL DATA DELIVERY STATUS frame is sent before any NR PDCP PDU is transferred to lower layers, the
   // information on the highest NR PDCP PDU sequence number successfully delivered in sequence to the UE and the
   // highest NR PDCP PDU sequence number transmitted to the lower layers may not be provided.
-  if (cur_highest_delivered_pdcp_sn != unset_pdcp_sn) {
-    logger.log_debug("Adding highest delivered pdcp_sn={}", cur_highest_delivered_pdcp_sn);
-    status.highest_delivered_pdcp_sn = cur_highest_delivered_pdcp_sn;
+  if (cur_highest_delivered_pdcp_sn == unset_pdcp_sn) {
+    return false;
+  }
+  logger.log_debug("Adding highest delivered pdcp_sn={}", cur_highest_delivered_pdcp_sn);
+  status.highest_delivered_pdcp_sn = cur_highest_delivered_pdcp_sn;
+  if (cur_highest_delivered_pdcp_sn != notif_highest_delivered_pdcp_sn) {
+    notif_highest_delivered_pdcp_sn = cur_highest_delivered_pdcp_sn;
     return true;
   }
   return false;
@@ -249,31 +257,31 @@ bool f1u_bearer_impl::fill_highest_delivered_retransmitted_pdcp_sn(nru_dl_data_d
   return false;
 }
 
-void f1u_bearer_impl::fill_data_delivery_status(nru_ul_message& msg)
+bool f1u_bearer_impl::fill_data_delivery_status(nru_ul_message& msg)
 {
-  nru_dl_data_delivery_status status      = {};
-  bool                        value_added = false;
+  nru_dl_data_delivery_status status       = {};
+  bool                        fresh_values = false;
 
-  value_added |= fill_desired_buffer_size_of_data_radio_bearer(status);
-  value_added |= fill_highest_transmitted_pdcp_sn(status);
-  value_added |= fill_highest_delivered_pdcp_sn(status);
-  value_added |= fill_highest_retransmitted_pdcp_sn(status);
-  value_added |= fill_highest_delivered_retransmitted_pdcp_sn(status);
+  fresh_values |= fill_desired_buffer_size_of_data_radio_bearer(status);
+  fresh_values |= fill_highest_transmitted_pdcp_sn(status);
+  fresh_values |= fill_highest_delivered_pdcp_sn(status);
+  fresh_values |= fill_highest_retransmitted_pdcp_sn(status);
+  fresh_values |= fill_highest_delivered_retransmitted_pdcp_sn(status);
 
-  if (value_added) {
-    logger.log_debug("Adding data delivery status to NR-U message");
-    msg.data_delivery_status = std::move(status);
-  }
+  logger.log_debug("Adding data delivery status to NR-U message");
+  msg.data_delivery_status = std::move(status);
 
   // restart UL notification timer
   ul_notif_timer.run();
+
+  return fresh_values;
 }
 
-bool f1u_bearer_impl::send_data_delivery_status()
+bool f1u_bearer_impl::send_data_delivery_status(bool force)
 {
-  nru_ul_message msg = {};
-  fill_data_delivery_status(msg);
-  if (!msg.data_delivery_status.has_value()) {
+  nru_ul_message msg          = {};
+  bool           fresh_values = fill_data_delivery_status(msg);
+  if (!fresh_values && !force) {
     return false;
   }
   tx_pdu_notifier.on_new_pdu(std::move(msg));
@@ -282,9 +290,9 @@ bool f1u_bearer_impl::send_data_delivery_status()
 
 void f1u_bearer_impl::on_expired_ul_notif_timer()
 {
-  if (send_data_delivery_status()) {
+  if (send_data_delivery_status(/* force = */ false)) {
     logger.log_debug("UL notification timer expired. Sent data delivery status");
   } else {
-    logger.log_debug("UL notification timer expired. No data to be sent in data delivery status");
+    logger.log_debug("UL notification timer expired. No fresh data to be sent in data delivery status");
   }
 }

lib/f1u/du/f1u_bearer_impl.h

@@ -97,18 +97,49 @@ class f1u_bearer_impl final : public f1u_bearer,
   /// Holds the latest information of the available space in the RLC SDU queue that was reported to the upper layers
   /// (i.e. torward CU-UP)
   uint32_t notif_desired_buffer_size_for_data_radio_bearer;
+  /// Holds the last highest transmitted PDCP SN that was reported to upper layers (i.e. towards CU-UP)
+  uint32_t notif_highest_transmitted_pdcp_sn = unset_pdcp_sn;
+  /// Holds the last highest delivered PDCP SN that was reported to upper layers (i.e. towards CU-UP)
+  uint32_t notif_highest_delivered_pdcp_sn = unset_pdcp_sn;
   /// Holds the last highest retransmitted PDCP SN that was reported to upper layers (i.e. towards CU-UP)
   uint32_t notif_highest_retransmitted_pdcp_sn = unset_pdcp_sn;
   /// Holds the last highest delivered retransmitted PDCP SN that was reported to upper layers (i.e. towards CU-UP)
   uint32_t notif_highest_delivered_retransmitted_pdcp_sn = unset_pdcp_sn;
 
+  /// \brief Write desired buffer size of DRB into DSSS.
+  /// \param status The DSSS to write the desired value into.
+  /// \return False if the same value was written as last time this function was called; True on fresh value.
   bool fill_desired_buffer_size_of_data_radio_bearer(nru_dl_data_delivery_status& status);
+
+  /// \brief Write highest transmitted PDCP SN into DSSS.
+  /// \param status The DSSS to write the desired value into.
+  /// \return False if the same value was written as last time this function was called; True on fresh value.
   bool fill_highest_transmitted_pdcp_sn(nru_dl_data_delivery_status& status);
+
+  /// \brief Write highest delivered PDCP SN into DSSS.
+  /// \param status The DSSS to write the desired value into.
+  /// \return False if the same value was written as last time this function was called; True on fresh value.
   bool fill_highest_delivered_pdcp_sn(nru_dl_data_delivery_status& status);
+
+  /// \brief Write highest retransmitted PDCP SN into DSSS.
+  /// \param status The DSSS to write the desired value into.
+  /// \return False if the same value was written as last time this function was called; True on fresh value.
   bool fill_highest_retransmitted_pdcp_sn(nru_dl_data_delivery_status& status);
+
+  /// \brief Write highest delivered retransmitted PDCP SN into DSSS.
+  /// \param status The DSSS to write the desired value into.
+  /// \return False if the same value was written as last time this function was called; True on fresh value.
   bool fill_highest_delivered_retransmitted_pdcp_sn(nru_dl_data_delivery_status& status);
-  void fill_data_delivery_status(nru_ul_message& msg);
-  bool send_data_delivery_status();
+
+  /// \brief Write DSSS into NR-U UL message.
+  /// \param msg NR-U UL message in which the DSSS shall be filled.
+  /// \return False if DSSS holds the same values as last time this function was called; True on fresh value(s).
+  bool fill_data_delivery_status(nru_ul_message& msg);
+
+  /// \brief Send a DSSS via dedicated NR-U UL message (no piggy-back) either if forced or contains fresh values.
+  /// \param force Force sending DSSS even if no fresh values are included (i.e. nothing changed since last call).
+  /// \return True if DSSS was sent, False otherwise.
+  bool send_data_delivery_status(bool force);
 
   void handle_pdu_impl(nru_dl_message msg);
 

tests/unittests/f1u/du/f1u_du_bearer_test.cpp

@@ -104,7 +104,8 @@ class f1u_du_test_base : public f1u_trx_test
   std::unique_ptr<f1u_bearer_impl>   f1u;
 
   gtpu_teid_t    dl_teid_next{1234};
-  const uint32_t f1u_ul_notif_time_ms = 10;
+  const uint32_t f1u_ul_notif_time_ms             = 10;
+  const uint32_t f1u_intial_rlc_queue_bytes_limit = 8000;
 };
 
 /// Fixture class for F1-U DU tests
@@ -116,9 +117,10 @@ class f1u_du_test : public ::testing::Test, public f1u_du_test_base
     // init test's logger
     init_logger();
     // create tester and testee
-    f1u_config config   = {};
-    config.t_notify     = f1u_ul_notif_time_ms;
-    config.warn_on_drop = true;
+    f1u_config config            = {};
+    config.t_notify              = f1u_ul_notif_time_ms;
+    config.rlc_queue_bytes_limit = f1u_intial_rlc_queue_bytes_limit;
+    config.warn_on_drop          = true;
     init_f1u(config);
   }
 
@@ -277,14 +279,38 @@ TEST_F(f1u_du_test, tx_pdcp_pdus)
 
   ASSERT_FALSE(tester->tx_msg_list.empty());
   EXPECT_EQ(tester->tx_msg_list.front().t_pdu.value(), tx_pdcp_pdu1);
-  EXPECT_FALSE(tester->tx_msg_list.front().data_delivery_status.has_value());
+  ASSERT_TRUE(tester->tx_msg_list.front().data_delivery_status.has_value());
+  {
+    nru_dl_data_delivery_status& status = tester->tx_msg_list.front().data_delivery_status.value();
+    EXPECT_FALSE(status.final_frame_ind);
+    EXPECT_EQ(status.desired_buffer_size_for_drb, f1u_intial_rlc_queue_bytes_limit);
+    EXPECT_FALSE(status.desired_data_rate);
+    EXPECT_FALSE(status.lost_nru_sn_ranges.has_value());
+    EXPECT_FALSE(status.highest_delivered_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_transmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.cause_value.has_value());
+    EXPECT_FALSE(status.highest_delivered_retransmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_retransmitted_pdcp_sn.has_value());
+  }
   EXPECT_FALSE(tester->tx_msg_list.front().assistance_information.has_value());
 
   tester->tx_msg_list.pop_front();
 
   ASSERT_FALSE(tester->tx_msg_list.empty());
   EXPECT_EQ(tester->tx_msg_list.front().t_pdu.value(), tx_pdcp_pdu2);
-  EXPECT_FALSE(tester->tx_msg_list.front().data_delivery_status.has_value());
+  ASSERT_TRUE(tester->tx_msg_list.front().data_delivery_status.has_value());
+  {
+    nru_dl_data_delivery_status& status = tester->tx_msg_list.front().data_delivery_status.value();
+    EXPECT_FALSE(status.final_frame_ind);
+    EXPECT_EQ(status.desired_buffer_size_for_drb, f1u_intial_rlc_queue_bytes_limit);
+    EXPECT_FALSE(status.desired_data_rate);
+    EXPECT_FALSE(status.lost_nru_sn_ranges.has_value());
+    EXPECT_FALSE(status.highest_delivered_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_transmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.cause_value.has_value());
+    EXPECT_FALSE(status.highest_delivered_retransmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_retransmitted_pdcp_sn.has_value());
+  }
   EXPECT_FALSE(tester->tx_msg_list.front().assistance_information.has_value());
 
   tester->tx_msg_list.pop_front();
@@ -635,8 +661,21 @@ TEST_F(f1u_du_test, rx_with_poll_triggers_no_ddds_when_nothing_was_notified)
   msg1.dl_user_data.report_polling = true;
   f1u->handle_pdu(std::move(msg1));
 
-  // This should not trigger a DDDS, because no data is available yet
-  EXPECT_TRUE(tester->tx_msg_list.empty());
+  // This triggers a DDDS that only includes the initial "desired_buffer_size_for_drb", no other data is available yet
+  ASSERT_TRUE(tester->tx_msg_list.front().data_delivery_status.has_value());
+  {
+    nru_dl_data_delivery_status& status = tester->tx_msg_list.front().data_delivery_status.value();
+    EXPECT_FALSE(status.final_frame_ind);
+    EXPECT_EQ(status.desired_buffer_size_for_drb, f1u_intial_rlc_queue_bytes_limit);
+    EXPECT_FALSE(status.desired_data_rate);
+    EXPECT_FALSE(status.lost_nru_sn_ranges.has_value());
+    EXPECT_FALSE(status.highest_delivered_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_transmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.cause_value.has_value());
+    EXPECT_FALSE(status.highest_delivered_retransmitted_pdcp_sn.has_value());
+    EXPECT_FALSE(status.highest_retransmitted_pdcp_sn.has_value());
+  }
+  EXPECT_FALSE(tester->tx_msg_list.front().assistance_information.has_value());
 
   // Also check that the DL PDU was properly forwarded
   ASSERT_FALSE(tester->rx_sdu_list.empty());