rlc,nru: notify "desired buffer size for DRB" according to TS 38.425

This value informs the CU of the amount of data per DRB to be sent beyond
the highest delivered PDCP SN (AM) or highest transmitted PDCP SN (UM).
It corresponds to the total capacity of the RLC queue (in bytes).

TS 38.245 Sec. 5.4.2.1:
(...)
- If the value of the desired buffer size is 0, the hosting node shall stop sending any data per bearer.
- If the value of the desired buffer size in b) above is greater than 0, the hosting node may send up to this
amount of data per bearer beyond the "Highest Delivered NR PDCP SN" for RLC AM, or the hosting node
may send up to this amount of data per bearer beyond the "Highest Transmitted NR PDCP SN" for RLM
UM.
(...)

Author: robertfalkenberg

include/srsran/f1ap/du/f1c_bearer.h

@@ -47,7 +47,7 @@ class f1c_tx_delivery_handler
   /// the lower layers (i.e. by the RLC).
   ///
   /// \param highest_sn Highest transmitted PDCP PDU sequence number.
-  virtual void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes) = 0;
+  virtual void handle_transmit_notification(uint32_t highest_pdcp_sn) = 0;
 
   /// \brief Informs the F1-C bearer about the highest PDCP PDU sequence number that was successfully
   /// delivered in sequence towards the UE.

include/srsran/f1u/du/f1u_tx_delivery_handler.h

@@ -27,14 +27,18 @@ class f1u_tx_delivery_handler
   ///
   /// Notification must be performed in ascending order of PDCP sequence numbers. It is the responsibility of the
   /// calling function (i.e. the RLC) to prevent out-of-order notifications.
+  /// The parameter \c desired_buf_size informs the CU of the amount of data per DRB to be sent beyond the
+  /// highest delivered PDCP SN (AM) or highest transmitted PDCP SN (UM).
+  /// This corresponds to the total capacity of the RLC queue (in bytes).
   ///
   /// This function is quick and shall be called directly from pcell_executor to avoid excessive transitions across
   /// executors.
   ///
   /// Safe execution from: pcell_executor
   ///
   /// \param highest_pdcp_sn The highest transmitted PDCP sequence number
-  virtual void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes) = 0;
+  /// \param desired_buf_size Desired buffer size for DRB
+  virtual void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t desired_buf_size) = 0;
 
   /// \brief Handles a delivery notification from lower layers (i.e. from RLC AM).
   ///

include/srsran/rlc/rlc_tx.h

@@ -89,7 +89,8 @@ class rlc_tx_upper_layer_data_notifier
   /// lower layers.
   ///
   /// \param max_tx_pdcp_sn Highest transmitted PDCP PDU sequence number.
-  virtual void on_transmitted_sdu(uint32_t max_tx_pdcp_sn, uint32_t bytes_free_in_queue) = 0;
+  /// \param desired_buf_size Desired buffer size for DRB. Ignored for SRBs.
+  virtual void on_transmitted_sdu(uint32_t max_tx_pdcp_sn, uint32_t desired_buf_size) = 0;
 
   /// \brief Informs upper layer about the highest PDCP PDU sequence number of the PDCP PDU that was successfully
   /// delivered in sequence towards the UE.

lib/du/du_high/du_manager/du_ue/du_ue_adapters.cpp

@@ -29,7 +29,7 @@ class null_sink_f1c_bearer : public f1c_bearer
   {
     return launch_no_op_task(true);
   }
-  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_bytes_free) override {}
+  void handle_transmit_notification(uint32_t highest_pdcp_sn) override {}
   void handle_delivery_notification(uint32_t highest_pdcp_sn) override {}
   void handle_sdu(byte_buffer_chain sdu) override {}
 } null_f1c_bearer;
@@ -46,7 +46,7 @@ class null_sink_f1u_bearer : public f1u_bearer,
   f1u_tx_sdu_handler&      get_tx_sdu_handler() override { return *this; }
 
   void handle_pdu(nru_dl_message msg) override {}
-  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_bytes_free) override {}
+  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t desired_buf_size) override {}
   void handle_delivery_notification(uint32_t highest_pdcp_sn) override {}
   void handle_retransmit_notification(uint32_t highest_pdcp_sn) override {}
   void handle_delivery_retransmitted_notification(uint32_t highest_pdcp_sn) override {}

lib/du/du_high/du_manager/du_ue/du_ue_adapters.h

@@ -127,11 +127,11 @@ class rlc_f1c_tx_data_notifier : public rlc_tx_upper_layer_data_notifier
 
   void disconnect();
 
-  void on_transmitted_sdu(uint32_t max_deliv_pdcp_sn, uint32_t queue_free_bytes) override
+  void on_transmitted_sdu(uint32_t max_deliv_pdcp_sn, uint32_t desired_buf_size) override
   {
     f1c_bearer* b = bearer.load(std::memory_order_relaxed);
     srsran_assert(b != nullptr, "RLC to F1-C TX data notifier is disconnected");
-    b->handle_transmit_notification(max_deliv_pdcp_sn, queue_free_bytes);
+    b->handle_transmit_notification(max_deliv_pdcp_sn);
   }
 
   void on_delivered_sdu(uint32_t max_deliv_pdcp_sn) override
@@ -166,11 +166,11 @@ class rlc_f1u_tx_data_notifier : public rlc_tx_upper_layer_data_notifier
 
   void disconnect();
 
-  void on_transmitted_sdu(uint32_t max_deliv_pdcp_sn, uint32_t queue_free_bytes) override
+  void on_transmitted_sdu(uint32_t max_deliv_pdcp_sn, uint32_t desired_buf_size) override
   {
     f1u_tx_delivery_handler* h = handler.load(std::memory_order_relaxed);
     srsran_assert(h != nullptr, "RLC to F1-U TX data notifier is disconnected");
-    h->handle_transmit_notification(max_deliv_pdcp_sn, queue_free_bytes);
+    h->handle_transmit_notification(max_deliv_pdcp_sn, desired_buf_size);
   }
 
   void on_delivered_sdu(uint32_t max_deliv_pdcp_sn) override

lib/f1ap/du/ue_context/f1c_du_bearer_impl.cpp

@@ -78,7 +78,7 @@ void f1c_srb0_du_bearer::handle_sdu(byte_buffer_chain sdu)
   }
 }
 
-void f1c_srb0_du_bearer::handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes)
+void f1c_srb0_du_bearer::handle_transmit_notification(uint32_t highest_pdcp_sn)
 {
   report_fatal_error("Transmission notifications do not exist for SRB0");
 }
@@ -221,7 +221,7 @@ async_task<bool> f1c_other_srb_du_bearer::handle_pdu_and_await_delivery(byte_buf
   return handle_pdu_and_await(std::move(pdu), false, time_to_wait);
 }
 
-void f1c_other_srb_du_bearer::handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes)
+void f1c_other_srb_du_bearer::handle_transmit_notification(uint32_t highest_pdcp_sn)
 {
   if (not ue_exec.defer([this, highest_pdcp_sn]() { handle_notification(highest_pdcp_sn, true); })) {
     logger.warning("Discarded transmit notification for SRB{} because the task executor queue is full.",

lib/f1ap/du/ue_context/f1c_du_bearer_impl.h

@@ -42,7 +42,7 @@ class f1c_srb0_du_bearer final : public f1c_bearer
   /// transfer message.
   void handle_sdu(byte_buffer_chain sdu) override;
 
-  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes) override;
+  void handle_transmit_notification(uint32_t highest_pdcp_sn) override;
   void handle_delivery_notification(uint32_t highest_pdcp_sn) override;
 
   void             handle_pdu(byte_buffer pdu) override;
@@ -78,7 +78,7 @@ class f1c_other_srb_du_bearer final : public f1c_bearer
   /// \param[in] sdu The message to be encoded in the RRC container of the UL RRC message transfer message to transmit.
   void handle_sdu(byte_buffer_chain sdu) override;
 
-  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_free_bytes) override;
+  void handle_transmit_notification(uint32_t highest_pdcp_sn) override;
   void handle_delivery_notification(uint32_t highest_pdcp_sn) override;
 
   void             handle_pdu(byte_buffer sdu) override;

lib/f1u/du/f1u_bearer_impl.cpp

@@ -104,13 +104,12 @@ void f1u_bearer_impl::handle_pdu_impl(nru_dl_message msg)
   }
 }
 
-void f1u_bearer_impl::handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_bytes_free)
+void f1u_bearer_impl::handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t desired_buf_size)
 {
   // This function may be called from pcell_executor, since it only writes to an atomic variable
-  logger.log_debug(
-      "Storing highest transmitted pdcp_sn={} and desired buffer size bs={}", highest_pdcp_sn, queue_bytes_free);
+  logger.log_debug("Storing highest transmitted pdcp_sn={} and desired_buf_size={}", highest_pdcp_sn, desired_buf_size);
   highest_transmitted_pdcp_sn.store(highest_pdcp_sn, std::memory_order_relaxed);
-  desired_buffer_size_for_data_radio_bearer.store(queue_bytes_free, std::memory_order_relaxed);
+  desired_buffer_size_for_data_radio_bearer.store(desired_buf_size, std::memory_order_relaxed);
 }
 
 void f1u_bearer_impl::handle_delivery_notification(uint32_t highest_pdcp_sn)

lib/f1u/du/f1u_bearer_impl.h

@@ -44,7 +44,7 @@ class f1u_bearer_impl final : public f1u_bearer,
   f1u_rx_pdu_handler&      get_rx_pdu_handler() override { return *this; }
 
   void handle_sdu(byte_buffer_chain sdu) override;
-  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t queue_bytes_free) override;
+  void handle_transmit_notification(uint32_t highest_pdcp_sn, uint32_t desired_buf_size) override;
   void handle_delivery_notification(uint32_t highest_pdcp_sn) override;
   void handle_retransmit_notification(uint32_t highest_pdcp_sn) override;
   void handle_delivery_retransmitted_notification(uint32_t highest_pdcp_sn) override;

lib/rlc/rlc_tx_am_entity.cpp

@@ -263,7 +263,13 @@ size_t rlc_tx_am_entity::build_new_pdu(span<uint8_t> rlc_pdu_buf)
     if (sdu.is_retx) {
       upper_dn.on_retransmitted_sdu(sdu.pdcp_sn.value());
     } else {
-      upper_dn.on_transmitted_sdu(sdu.pdcp_sn.value(), cfg.queue_size_bytes - queue_state.n_bytes);
+      // Use size of SDU queue for desired_buf_size
+      //
+      // From TS 38.425 Sec. 5.4.2.1:
+      // - If the value of the desired buffer size is 0, the hosting node shall stop sending any data per bearer.
+      // - If the value of the desired buffer size in b) above is greater than 0, the hosting node may send up to this
+      //   amount of data per bearer beyond the "Highest Delivered NR PDCP SN" for RLC AM, (...)
+      upper_dn.on_transmitted_sdu(sdu.pdcp_sn.value(), cfg.queue_size_bytes);
     }
   }