phy,gnb: review metrics

phy: fix metric decorators

phy: review metrics docs

phy: review

Author: xavierarteaga

apps/units/flexible_o_du/split_helpers/metrics/flexible_o_du_metrics_consumers.cpp

@@ -215,7 +215,7 @@ void flexible_o_du_metrics_consumer_json::handle_metric(const app_services::metr
   const auto& metric_enc         = odu_metrics.du.low.ldpc_metrics.encoder_metrics;
   double      ldpc_enc_cpu_usage = 100.0 * metric_enc.cpu_usage_us / metric_period_us;
   ldpc_encoder.write<metric_average_cb_size>(metric_enc.avg_cb_size);
-  ldpc_encoder.write<metric_average_latency>(metric_enc.avg_cb_latency);
+  ldpc_encoder.write<metric_average_latency>(metric_enc.avg_cb_latency_us);
   ldpc_encoder.write<metric_min_latency>(metric_enc.min_cb_latency_us);
   ldpc_encoder.write<metric_max_latency>(metric_enc.max_cb_latency_us);
   ldpc_encoder.write<metric_avg_throughput_mbps>(metric_enc.encoding_rate_Mbps);
@@ -456,14 +456,22 @@ static void log_upper_phy_metrics_verbose(fmt::basic_memory_buffer<char, str_buf
   double pusch_wait_time_percent =
       validate_fp_value(100.0 * static_cast<double>(du_lo.pusch_metrics.pusch_proc_metrics.total_wait_time.count()) /
                         static_cast<double>(du_lo.pusch_metrics.pusch_proc_metrics.total_proc_time.count()));
+  fmt::format_to(std::back_inserter(buffer), "\n");
+
+  const auto& dl_processor = du_lo.dl_processor_metrics;
+  fmt::format_to(std::back_inserter(buffer),
+                 "{:<25} max_latency={:.2f} us in slot={}\n",
+                 "  DL processing:",
+                 validate_fp_value(dl_processor.max_latency_us.first),
+                 dl_processor.max_latency_us.second);
 
   const auto& ldpc_encoder = du_lo.ldpc_metrics.encoder_metrics;
   fmt::format_to(std::back_inserter(buffer),
                  "{:<25} avg_cb_size={:.2f} bits, avg_latency={:.2f} us, max_latency={:.2f} us, "
                  "encode_rate={:.2f} Mbps\n",
                  "  LDPC Encoder:",
                  validate_fp_value(ldpc_encoder.avg_cb_size),
-                 validate_fp_value(ldpc_encoder.avg_cb_latency),
+                 validate_fp_value(ldpc_encoder.avg_cb_latency_us),
                  validate_fp_value(ldpc_encoder.max_cb_latency_us),
                  validate_fp_value(ldpc_encoder.encoding_rate_Mbps));
 
@@ -634,38 +642,6 @@ static void log_upper_phy_metrics_verbose(fmt::basic_memory_buffer<char, str_buf
   fmt::format_to(std::back_inserter(buffer), "     |-> UL-SCH Demux: {:.2f} %\n", ulsch_demux_percent);
   fmt::format_to(
       std::back_inserter(buffer), "     |------> Decoder: {:.2f} % (multi-threaded)\n", pusch_wait_time_percent);
-}
-
-static void
-log_handle_du_low_metrics(srslog::log_channel& log_chan, const srs_du::o_du_low_metrics& du_lo, bool verbose)
-{
-  if (du_lo.metrics_period == std::chrono::microseconds()) {
-    return;
-  }
-
-  fmt::basic_memory_buffer<char, str_buffer_size> buffer;
-  fmt::format_to(std::back_inserter(buffer), "Upper PHY metrics:\n");
-
-  // Verbose logging.
-  if (verbose) {
-    log_upper_phy_metrics_verbose(buffer, du_lo);
-  }
-
-  const auto& ldpc_encoder    = du_lo.ldpc_metrics.encoder_metrics;
-  const auto& ldpc_decoder    = du_lo.ldpc_metrics.decoder_metrics;
-  const auto& ldpc_rm         = du_lo.ldpc_metrics.rate_match_metrics;
-  const auto& ldpc_rdm        = du_lo.ldpc_metrics.rate_dematch_metrics;
-  const auto& crc_pdsch       = du_lo.pdsch_metrics.crc_metrics;
-  const auto& crc_pusch       = du_lo.pusch_metrics.crc_metrics;
-  const auto& prg_pdsch       = du_lo.pdsch_metrics.scrambling_metrics;
-  const auto& prg_pusch       = du_lo.pusch_metrics.scrambling_metrics;
-  const auto& pusch_demod_map = du_lo.pusch_metrics.demod_demapper_metrics;
-  const auto& pdsch_mod       = du_lo.pdsch_metrics.modulator_metrics;
-  const auto& pdsch_dmrs      = du_lo.pdsch_metrics.dmrs_metrics;
-  const auto& p               = du_lo.pdsch_metrics.precoding_metrics;
-  const auto& xform           = du_lo.pusch_metrics.xform_precoder_metrics;
-  const auto& pdsch_proc      = du_lo.pdsch_metrics.pdsch_proc_metrics;
-  const auto& pusch_proc      = du_lo.pusch_metrics.pusch_proc_metrics;
 
   // CPU consumption.
   double metric_period_us   = static_cast<double>(du_lo.metrics_period.count());
@@ -711,6 +687,41 @@ log_handle_du_low_metrics(srslog::log_channel& log_chan, const srs_du::o_du_low_
                  validate_fp_value(descramble_cpu_usage),
                  validate_fp_value(pusch_demod_map_cpu),
                  validate_fp_value(pusch_precode_cpu_usage));
+}
+
+static void
+log_handle_du_low_metrics(srslog::log_channel& log_chan, const srs_du::o_du_low_metrics& du_lo, bool verbose)
+{
+  if (du_lo.metrics_period == std::chrono::microseconds()) {
+    return;
+  }
+
+  fmt::basic_memory_buffer<char, str_buffer_size> buffer;
+  fmt::format_to(std::back_inserter(buffer),
+                 "PHY metrics: "
+                 "dl_processing_max_latency={:.1f}us "
+                 "dl_processing_max_slot={} "
+                 "ul_processing_max_latency={:.1f}us "
+                 "ul_processing_max_slot={} "
+                 "ldpc_encoder_avg_latency={:.1f}us "
+                 "ldpc_encoder_max_latency={:.1f}us "
+                 "ldpc_decoder_avg_latency={:.1f}us "
+                 "ldp_decoder_max_latency={:.1f}us "
+                 "ldpc_decoder_avg_nof_iter={}",
+                 validate_fp_value(du_lo.dl_processor_metrics.max_latency_us.first),
+                 du_lo.dl_processor_metrics.max_latency_us.second,
+                 validate_fp_value(du_lo.pusch_metrics.pusch_proc_metrics.max_data_latency_us.first),
+                 du_lo.pusch_metrics.pusch_proc_metrics.max_data_latency_us.second,
+                 du_lo.ldpc_metrics.encoder_metrics.avg_cb_latency_us,
+                 du_lo.ldpc_metrics.encoder_metrics.max_cb_latency_us,
+                 du_lo.ldpc_metrics.decoder_metrics.avg_cb_latency_us,
+                 du_lo.ldpc_metrics.decoder_metrics.max_cb_latency_us,
+                 du_lo.ldpc_metrics.decoder_metrics.avg_nof_iterations);
+
+  // Verbose logging.
+  if (verbose) {
+    log_upper_phy_metrics_verbose(buffer, du_lo);
+  }
 
   // Flush buffer to the logger.
   log_chan("{}", to_c_str(buffer));

apps/units/flexible_o_du/split_helpers/metrics/flexible_o_du_metrics_consumers.h

@@ -25,7 +25,7 @@ struct ru_metrics;
 class flexible_o_du_metrics_consumer_log : public app_services::metrics_consumer
 {
 public:
-  explicit flexible_o_du_metrics_consumer_log(srslog::log_channel& log_chan_) : log_chan(log_chan_), verbose(true)
+  explicit flexible_o_du_metrics_consumer_log(srslog::log_channel& log_chan_) : log_chan(log_chan_), verbose(false)
   {
     srsran_assert(log_chan.enabled(), "Logger log channel is not enabled");
   }

include/srsran/du/du_low/o_du_low_metrics.h

@@ -44,7 +44,7 @@ struct o_du_low_ldpc_metrics {
     /// Average codeblock size in bits.
     double avg_cb_size;
     /// Average codeblock latency in microseconds.
-    double avg_cb_latency;
+    double avg_cb_latency_us;
     /// Minimum codeblock latency in microseconds.
     double min_cb_latency_us;
     /// Maximum codeblock latency in microseconds.
@@ -227,7 +227,7 @@ struct o_du_low_pusch_metrics {
     /// Minimum data processing latency in microseconds.
     double min_data_latency_us;
     /// Maximum data processing latency in microseconds.
-    double max_data_latency_us;
+    std::pair<double, slot_point> max_data_latency_us;
     /// Average UCI processing latency in microseconds.
     double avg_uci_latency_us;
     /// Minimum UCI processing latency in microseconds.
@@ -313,12 +313,20 @@ struct o_du_low_pdsch_metrics {
   pdsch_processing_metrics       pdsch_proc_metrics;
 };
 
+/// Aggregates downlink processor metrics.
+struct o_du_low_dl_processor_metrics {
+  double                        min_latency_us;
+  double                        avg_latency_us;
+  std::pair<double, slot_point> max_latency_us;
+};
+
 /// O-RAN DU low metrics.
 struct o_du_low_metrics {
-  o_du_low_ldpc_metrics     ldpc_metrics;
-  o_du_low_pusch_metrics    pusch_metrics;
-  o_du_low_pdsch_metrics    pdsch_metrics;
-  std::chrono::microseconds metrics_period;
+  o_du_low_ldpc_metrics         ldpc_metrics;
+  o_du_low_pusch_metrics        pusch_metrics;
+  o_du_low_pdsch_metrics        pdsch_metrics;
+  o_du_low_dl_processor_metrics dl_processor_metrics;
+  std::chrono::microseconds     metrics_period;
 };
 
 } // namespace srs_du

include/srsran/phy/metrics/phy_metrics_factories.h

@@ -15,6 +15,7 @@
 #include "srsran/phy/upper/channel_processors/pdsch/factories.h"
 #include "srsran/phy/upper/channel_processors/pusch/factories.h"
 #include "srsran/phy/upper/signal_processors/signal_processor_factories.h"
+#include "srsran/phy/upper/upper_phy_factories.h"
 
 namespace srsran {
 
@@ -116,4 +117,9 @@ std::shared_ptr<dmrs_pdsch_processor_factory>
 create_dmrs_pdsch_generator_metric_decorator_factory(std::shared_ptr<dmrs_pdsch_processor_factory> base_factory,
                                                      pdsch_dmrs_generator_metric_notifier&         notifier);
 
+/// Creates a downlink processor metric decorator factory.
+std::shared_ptr<downlink_processor_factory>
+create_downlink_processor_generator_metric_decorator_factory(std::shared_ptr<downlink_processor_factory> base_factory,
+                                                             downlink_processor_metric_notifier&         notifier);
+
 } // namespace srsran

include/srsran/phy/metrics/phy_metrics_notifiers.h

@@ -54,6 +54,7 @@ using port_channel_estimator_metric_notifier    = detail::phy_metric_notifier<po
 using transform_precoder_metric_notifier        = detail::phy_metric_notifier<transform_precoder_metrics>;
 using pdsch_processor_metric_notifier           = detail::phy_metric_notifier<pdsch_processor_metrics>;
 using pdsch_dmrs_generator_metric_notifier      = detail::phy_metric_notifier<pdsch_dmrs_generator_metrics>;
+using downlink_processor_metric_notifier        = detail::phy_metric_notifier<downlink_processor_metrics>;
 
 /// Groups upper physical layer metric notifiers.
 class upper_phy_metrics_notifiers
@@ -81,7 +82,8 @@ class upper_phy_metrics_notifiers
   virtual port_channel_estimator_metric_notifier&           get_pusch_port_channel_estimator_notifier() = 0;
   virtual transform_precoder_metric_notifier&               get_pusch_transform_precoder_notifier()     = 0;
   virtual pdsch_processor_metric_notifier&                  get_pdsch_processor_notifier()              = 0;
-  virtual pdsch_dmrs_generator_metric_notifier&             get_pdsch_dmrs_generator()                  = 0;
+  virtual pdsch_dmrs_generator_metric_notifier&             get_pdsch_dmrs_generator_notifier()         = 0;
+  virtual downlink_processor_metric_notifier&               get_downlink_processor_notifier()           = 0;
 };
 
 } // namespace srsran

include/srsran/phy/metrics/phy_metrics_reports.h

@@ -76,6 +76,8 @@ struct pusch_channel_estimator_metrics {
 
 /// Collects PUSCH processor metrics.
 struct pusch_processor_metrics {
+  /// Slot context
+  slot_point slot;
   /// Codeblock size.
   units::bytes tbs;
   /// Set to true if the CRC matches.
@@ -226,4 +228,19 @@ struct pdsch_dmrs_generator_metrics {
   resource_usage_utils::measurements measurements;
 };
 
+/// Collects upper PHY downlink processor metrics.
+struct downlink_processor_metrics {
+  /// Slot context
+  slot_point slot;
+
+  /// Elapsed time that comprises the configuration of the resource grid and the completion of PDUs.
+  std::chrono::nanoseconds elapsed_data;
+  /// Elapsed time between the time point in which the resource grid is configured and the time point the resource grid
+  /// is sent over the gateway.
+  std::chrono::nanoseconds elapsed_configure;
+  /// Elapsed time between the time point in the downlink processor PDU queueing is completed and the time point the
+  /// resource grid is sent over the gateway.
+  std::chrono::nanoseconds elapsed_finish;
+};
+
 } // namespace srsran

lib/du/du_low/metrics/aggregators/downlink_processor_metrics_aggregator.h

@@ -0,0 +1,87 @@
+/*
+ *
+ * Copyright 2021-2025 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.
+ *
+ */
+
+#pragma once
+
+#include "aggregator_helpers.h"
+#include "srsran/phy/metrics/phy_metrics_notifiers.h"
+#include "srsran/phy/metrics/phy_metrics_reports.h"
+#include <atomic>
+#include <utility>
+
+namespace srsran {
+
+/// Downlink processor metrics aggregator.
+class downlink_processor_metrics_aggregator : public downlink_processor_metric_notifier
+{
+public:
+  /// Gets the average transmission latency in microseconds.
+  double get_avg_latency_us() const
+  {
+    return count.load(std::memory_order_relaxed)
+               ? static_cast<double>(sum_elapsed_finish_ns) / static_cast<double>(count) * 1e-3
+               : 0;
+  }
+
+  /// Gets the minimum transmission latency in microseconds.
+  double get_min_latency_us() const
+  {
+    uint64_t min_latency_ns = unpack_duration(packed_min_latency_ns);
+    return (min_latency_ns == unpack_duration(default_packed_min_latency_ns))
+               ? 0
+               : static_cast<double>(min_latency_ns) / 1000.0;
+  }
+
+  /// Gets the maximum transmission latency in microseconds and the slot point in which was detected.
+  std::pair<double, slot_point> get_max_latency_us() const
+  {
+    uint64_t   packed_max_latency = packed_max_latency_ns;
+    uint64_t   max_latency_ns     = unpack_duration(packed_max_latency);
+    slot_point slot               = unpack_slot(packed_max_latency);
+    return {static_cast<double>(max_latency_ns) / 1000.0, slot};
+  }
+
+  /// Resets values of all internal counters.
+  void reset()
+  {
+    count                    = 0;
+    sum_elapsed_data_ns      = 0;
+    sum_elapsed_configure_ns = 0;
+    sum_elapsed_finish_ns    = 0;
+    packed_min_latency_ns    = default_packed_min_latency_ns;
+    packed_max_latency_ns    = default_packed_max_latency_ns;
+  }
+
+private:
+  static constexpr uint64_t default_packed_min_latency_ns =
+      pack_slot_and_duration({}, std::numeric_limits<uint32_t>::max());
+  static constexpr uint64_t default_packed_max_latency_ns =
+      pack_slot_and_duration({}, std::numeric_limits<uint32_t>::min());
+
+  // See interface for documentation.
+  void on_new_metric(const downlink_processor_metrics& metrics) override
+  {
+    sum_elapsed_data_ns += metrics.elapsed_data.count();
+    sum_elapsed_configure_ns += metrics.elapsed_configure.count();
+    sum_elapsed_finish_ns += metrics.elapsed_finish.count();
+    update_slotmin(metrics.slot, metrics.elapsed_finish.count(), packed_min_latency_ns);
+    update_slotmax(metrics.slot, metrics.elapsed_finish.count(), packed_max_latency_ns);
+    ++count;
+  }
+
+  std::atomic<uint64_t> sum_elapsed_data_ns      = {};
+  std::atomic<uint64_t> sum_elapsed_configure_ns = {};
+  std::atomic<uint64_t> sum_elapsed_finish_ns    = {};
+  std::atomic<uint64_t> count                    = {};
+  std::atomic<uint64_t> packed_min_latency_ns    = default_packed_min_latency_ns;
+  std::atomic<uint64_t> packed_max_latency_ns    = default_packed_max_latency_ns;
+};
+
+} // namespace srsran