rlc: refactor queue formatter...

...in preparation of rendering of log messages in backend.
(Otherwise the queue would need to be copied to the backend)

Author: robertfalkenberg

lib/rlc/rlc_sdu_queue_lockfree.h

@@ -199,6 +199,19 @@ class rlc_sdu_queue_lockfree
   /// \return The number of buffered SDU bytes that are not marked as discarded.
   uint32_t size_bytes() const { return n_bytes.load(std::memory_order_relaxed); }
 
+  /// \brief Container for return value of \c get_state function.
+  struct state {
+    uint32_t n_sdus;  ///< Number of buffered SDUs that are not marked as discarded.
+    uint32_t n_bytes; ///< Number of buffered bytes that are not marked as discarded.
+  };
+
+  /// \brief Reads the state of the queue, i.e. number of buffered SDUs and bytes that are not marked as discarded.
+  ///
+  /// This function may be called by any thread.
+  ///
+  /// \return Current state of the queue.
+  state get_state() const { return {size_sdus(), size_bytes()}; }
+
   /// \brief Checks if the internal queue is empty.
   ///
   /// This function may be called by any thread.
@@ -281,18 +294,18 @@ class rlc_sdu_queue_lockfree
 
 namespace fmt {
 template <>
-struct formatter<srsran::rlc_sdu_queue_lockfree> {
+struct formatter<srsran::rlc_sdu_queue_lockfree::state> {
   template <typename ParseContext>
   auto parse(ParseContext& ctx) -> decltype(ctx.begin())
   {
     return ctx.begin();
   }
 
   template <typename FormatContext>
-  auto format(const srsran::rlc_sdu_queue_lockfree& q, FormatContext& ctx)
+  auto format(const srsran::rlc_sdu_queue_lockfree::state& state, FormatContext& ctx)
       -> decltype(std::declval<FormatContext>().out())
   {
-    return format_to(ctx.out(), "queued_sdus={} queued_bytes={}", q.size_sdus(), q.size_bytes());
+    return format_to(ctx.out(), "queued_sdus={} queued_bytes={}", state.n_sdus, state.n_bytes);
   }
 };
 

lib/rlc/rlc_tx_am_entity.cpp

@@ -67,12 +67,16 @@ void rlc_tx_am_entity::handle_sdu(rlc_sdu sdu)
   sdu.time_of_arrival = std::chrono::high_resolution_clock::now();
   size_t sdu_length   = sdu.buf.length();
   if (sdu_queue.write(sdu)) {
-    logger.log_info(
-        sdu.buf.begin(), sdu.buf.end(), "TX SDU. sdu_len={} pdcp_sn={} {}", sdu.buf.length(), sdu.pdcp_sn, sdu_queue);
+    logger.log_info(sdu.buf.begin(),
+                    sdu.buf.end(),
+                    "TX SDU. sdu_len={} pdcp_sn={} {}",
+                    sdu.buf.length(),
+                    sdu.pdcp_sn,
+                    sdu_queue.get_state());
     metrics.metrics_add_sdus(1, sdu_length);
     handle_changed_buffer_state();
   } else {
-    logger.log_warning("Dropped SDU. sdu_len={} pdcp_sn={} {}", sdu_length, sdu.pdcp_sn, sdu_queue);
+    logger.log_warning("Dropped SDU. sdu_len={} pdcp_sn={} {}", sdu_length, sdu.pdcp_sn, sdu_queue.get_state());
     metrics.metrics_add_lost_sdus(1);
   }
 }
@@ -180,7 +184,7 @@ size_t rlc_tx_am_entity::build_new_pdu(span<uint8_t> rlc_pdu_buf)
 
   // Read new SDU from TX queue
   rlc_sdu sdu;
-  logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue);
+  logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue.get_state());
   if (not sdu_queue.read(sdu)) {
     logger.log_debug("SDU queue empty. grant_len={}", grant_len);
     return 0;

lib/rlc/rlc_tx_tm_entity.cpp

@@ -37,11 +37,11 @@ void rlc_tx_tm_entity::handle_sdu(rlc_sdu sdu_)
 {
   size_t sdu_len = sdu_.buf.length();
   if (sdu_queue.write(sdu_)) {
-    logger.log_info(sdu_.buf.begin(), sdu_.buf.end(), "TX SDU. sdu_len={} {}", sdu_len, sdu_queue);
+    logger.log_info(sdu_.buf.begin(), sdu_.buf.end(), "TX SDU. sdu_len={} {}", sdu_len, sdu_queue.get_state());
     metrics.metrics_add_sdus(1, sdu_len);
     handle_changed_buffer_state();
   } else {
-    logger.log_info("Dropped SDU. sdu_len={} {}", sdu_len, sdu_queue);
+    logger.log_info("Dropped SDU. sdu_len={} {}", sdu_len, sdu_queue.get_state());
     metrics.metrics_add_lost_sdus(1);
   }
 }
@@ -61,7 +61,7 @@ size_t rlc_tx_tm_entity::pull_pdu(span<uint8_t> mac_sdu_buf)
 
   // Get a new SDU, if none is currently being transmitted
   if (sdu.buf.empty()) {
-    logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue);
+    logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue.get_state());
     if (not sdu_queue.read(sdu)) {
       logger.log_debug("SDU queue empty. grant_len={}", grant_len);
       return 0;

lib/rlc/rlc_tx_um_entity.cpp

@@ -50,11 +50,11 @@ void rlc_tx_um_entity::handle_sdu(rlc_sdu sdu_)
                     "TX SDU. sdu_len={} pdcp_sn={} {}",
                     sdu_.buf.length(),
                     sdu_.pdcp_sn,
-                    sdu_queue);
+                    sdu_queue.get_state());
     metrics.metrics_add_sdus(1, sdu_length);
     handle_changed_buffer_state();
   } else {
-    logger.log_info("Dropped SDU. sdu_len={} pdcp_sn={} {}", sdu_length, sdu_.pdcp_sn, sdu_queue);
+    logger.log_info("Dropped SDU. sdu_len={} pdcp_sn={} {}", sdu_length, sdu_.pdcp_sn, sdu_queue.get_state());
     metrics.metrics_add_lost_sdus(1);
   }
 }
@@ -92,7 +92,7 @@ size_t rlc_tx_um_entity::pull_pdu(span<uint8_t> mac_sdu_buf)
   // Get a new SDU, if none is currently being transmitted
   if (sdu.buf.empty()) {
     srsran_sanity_check(next_so == 0, "New TX SDU, but next_so={} > 0.", next_so);
-    logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue);
+    logger.log_debug("Reading SDU from sdu_queue. {}", sdu_queue.get_state());
     if (not sdu_queue.read(sdu)) {
       logger.log_debug("SDU queue empty. grant_len={}", grant_len);
       return {};