Update main

# Conflicts:
#	lib/scheduler/policy/slice_allocator.h
#	lib/scheduler/policy/ue_allocator.h

Author: codebot

.github/workflows/ccpp.yml

@@ -18,7 +18,10 @@ jobs:
         os: [ubuntu-24.04]
         compiler: [gcc]
     steps:
-    - uses: actions/checkout@v3
+    - uses: actions/checkout@v4
+      with:
+        submodules: recursive
+        token: ${{ secrets.CI_TOKEN != '' && secrets.CI_TOKEN || github.token }}
     - name: Install Dependencies
       run: |
         sudo docker/scripts/install_dependencies.sh

.gitlab/ci/docker.yml

@@ -265,14 +265,26 @@ grafana server image:
     NAME: grafana
     CONTEXT: ${CI_PROJECT_DIR}/docker/grafana
     MODE: publish
-  before_script:
+  before_script: &grafana_before_script
+    - |
+      if [ -n "$LOGO_URL" ]; then
+        DEBIAN_FRONTEND=noninteractive apt-get update && apt-get install -y --no-install-recommends ca-certificates wget
+        wget --header="PRIVATE-TOKEN: $CODEBOT_TOKEN" -O ${CONTEXT}/provisioning/logo.png ${LOGO_URL}
+        export BUILD_ARGS="LOGO_SRC=/etc/grafana/provisioning/logo.png"
+      fi
     - |
       export VERSION=$(cat docker/grafana/version.yml | grep SRS_GRAFANA_VERSION | cut -d'"' -f2)
+  parallel:
+    matrix:
+      - REGISTRY_ORG: /${CI_PROJECT_NAME}
+      - REGISTRY_ORG: /${SRSRAN_IMAGE_PREFIX}
+        LOGO_URL: ${SRSRAN_IMAGE_LOGO_URL}
 
 grafana server image latest:
   extends: grafana server image
   variables:
     OVERWRITE: "true"
   before_script:
+    - *grafana_before_script
     - |
       export VERSION=latest

.gitlab/ci/e2e.yml

@@ -265,6 +265,7 @@ amari 32UE:
             "iperf and udp and not band:3",
             "iperf and tcp and band:3",
             "iperf and tcp and not band:3",
+            "pucch",
           ]
 
 amari 32UE [ping]:

.gitlab/ci/release.yml

@@ -195,7 +195,7 @@ download final branch:
   before_script:
     - *git_setup
   script:
-    - git clone --branch ${PRIVATE_BRANCH} https://${CODEBOT_USERNAME}:${CODEBOT_TOKEN}@gitlab.com/${CI_PROJECT_NAMESPACE}/${CI_PROJECT_NAME}.git ${CI_PROJECT_DIR}
+    - git clone --recurse-submodules --branch ${PRIVATE_BRANCH} https://${CODEBOT_USERNAME}:${CODEBOT_TOKEN}@gitlab.com/${CI_PROJECT_NAMESPACE}/${CI_PROJECT_NAME}.git ${CI_PROJECT_DIR}
     - cd ${CI_PROJECT_DIR}
     - git config --global --add safe.directory ${CI_PROJECT_DIR}
   artifacts:

apps/units/flexible_o_du/o_du_high/du_high/metrics/du_high_mac_metrics_consumers.cpp

@@ -23,6 +23,7 @@
 #include "du_high_mac_metrics_consumers.h"
 #include "srsran/mac/mac_metrics.h"
 #include "srsran/ran/pci.h"
+#include "srsran/support/format/fmt_to_c_str.h"
 
 using namespace srsran;
 
@@ -86,3 +87,50 @@ void mac_metrics_consumer_json::handle_metric(const app_services::metrics_set& m
   ctx.write<metric_timestamp_tag>(get_time_stamp());
   log_chan(ctx);
 }
+
+static void write_latency_information(fmt::memory_buffer&                              buffer,
+                                      const mac_dl_cell_metric_report::latency_report& report,
+                                      std::string_view                                 name,
+                                      bool                                             add_space    = true,
+                                      bool                                             add_new_line = false)
+{
+  fmt::format_to(std::back_inserter(buffer),
+                 "{}=[avg={}usec max={}usec max_slot={}]",
+                 name,
+                 std::round(report.average.count() * 1e-3),
+                 std::round(report.max.count() * 1e-3),
+                 report.max_slot);
+
+  if (add_space) {
+    fmt::format_to(std::back_inserter(buffer), " ");
+  }
+  if (add_new_line) {
+    fmt::format_to(std::back_inserter(buffer), "\n");
+  }
+}
+
+void mac_metrics_consumer_log::handle_metric(const app_services::metrics_set& metric)
+{
+  const mac_metric_report& mac_metrics = static_cast<const mac_metrics_impl&>(metric).get_metrics();
+
+  fmt::memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), "Mac Metrics: \n");
+
+  for (unsigned i = 0, e = mac_metrics.dl.cells.size(), last_index = e - 1; i != e; ++i) {
+    const mac_dl_cell_metric_report& cell = mac_metrics.dl.cells[i];
+
+    fmt::format_to(std::back_inserter(buffer),
+                   "  - pci={} nof_slots={} slot_duration={}usec nof_voluntary_context_switches={} "
+                   "nof_involuntary_context_switches={} ",
+                   static_cast<unsigned>(cell.pci),
+                   cell.nof_slots,
+                   std::round(cell.slot_duration.count() * 1e-3),
+                   cell.count_voluntary_context_switches,
+                   cell.count_involuntary_context_switches);
+
+    write_latency_information(buffer, cell.wall_clock_latency, "wall_clock_latency");
+    write_latency_information(buffer, cell.slot_ind_handle_latency, "slot_ind_latency", false, i != last_index);
+  }
+
+  log_chan("{}", to_c_str(buffer));
+}

apps/units/flexible_o_du/o_du_high/du_high/metrics/du_high_mac_metrics_consumers.h

@@ -40,4 +40,17 @@ class mac_metrics_consumer_json : public app_services::metrics_consumer
   srslog::log_channel& log_chan;
 };
 
+/// Consumer for the logger MAC metrics.
+class mac_metrics_consumer_log : public app_services::metrics_consumer
+{
+public:
+  explicit mac_metrics_consumer_log(srslog::log_channel& log_chan_) : log_chan(log_chan_) {}
+
+  // See interface for documentation.
+  void handle_metric(const app_services::metrics_set& metric) override;
+
+private:
+  srslog::log_channel& log_chan;
+};
+
 } // namespace srsran

apps/units/flexible_o_du/o_du_high/du_high/metrics/du_high_scheduler_cell_metrics_consumers.cpp

@@ -24,6 +24,7 @@
 #include "du_high_rlc_metrics.h"
 #include "srsran/scheduler/scheduler_metrics.h"
 #include "srsran/support/engineering_notation.h"
+#include "srsran/support/format/custom_formattable.h"
 #include "fmt/ranges.h"
 #include "fmt/std.h"
 #include <ostream>
@@ -113,11 +114,13 @@ DECLARE_METRIC_SET("cell_events", mset_cell_event, metric_sfn, metric_slot_index
 /// cell-wide metrics.
 DECLARE_METRIC("error_indication_count", metric_error_indication_count, unsigned, "");
 DECLARE_METRIC("average_latency", metric_average_latency, unsigned, "");
+DECLARE_METRIC("max_latency", metric_max_latency, unsigned, "");
 DECLARE_METRIC("latency_histogram", latency_histogram, std::vector<unsigned>, "");
 DECLARE_METRIC_SET("cell_metrics",
                    cell_metrics,
                    metric_error_indication_count,
                    metric_average_latency,
+                   metric_max_latency,
                    latency_histogram);
 
 /// Metrics root object.
@@ -223,7 +226,7 @@ void scheduler_cell_metrics_consumer_stdout::handle_metric(const app_services::m
     if (ue.ul_ri_stats.get_nof_observations() > 0) {
       fmt::print(" {:>3.1f}", ue.ul_ri_stats.get_mean());
     } else {
-      fmt::print(" {:>3}", "n/a");
+      fmt::print("   1");
     }
 
     fmt::print("   {:>2}", ue.ul_mcs.to_uint());
@@ -342,6 +345,7 @@ void scheduler_cell_metrics_consumer_json::handle_metric(const app_services::met
   auto& cell_output = ctx.get<cell_metrics>();
   cell_output.write<metric_error_indication_count>(metrics.nof_error_indications);
   cell_output.write<metric_average_latency>(metrics.average_decision_latency.count());
+  cell_output.write<metric_max_latency>(metrics.max_decision_latency.count());
   cell_output.write<latency_histogram>(
       std::vector<unsigned>(metrics.latency_histogram.begin(), metrics.latency_histogram.end()));
 
@@ -364,25 +368,62 @@ void scheduler_cell_metrics_consumer_log::handle_metric(const app_services::metr
 
   unsigned sum_dl_bitrate_kbps = 0;
   unsigned sum_ul_bitrate_kbps = 0;
+  unsigned sum_pdsch_rbs       = 0;
+  unsigned sum_pusch_rbs       = 0;
+  float    max_crc_delay       = std::numeric_limits<float>::min();
+  float    max_ce_delay        = std::numeric_limits<float>::min();
+  float    max_pucch_delay     = std::numeric_limits<float>::min();
+  float    max_pusch_delay     = std::numeric_limits<float>::min();
   for (const auto& ue : metrics.ue_metrics) {
     sum_dl_bitrate_kbps += ue.dl_brate_kbps;
     sum_ul_bitrate_kbps += ue.ul_brate_kbps;
+    sum_pdsch_rbs += ue.tot_pdsch_prbs_used;
+    sum_pusch_rbs += ue.tot_pusch_prbs_used;
+    if (ue.max_crc_delay_ms.has_value()) {
+      max_crc_delay = std::max(max_crc_delay, ue.max_crc_delay_ms.value());
+    }
+    if (ue.max_ce_delay_ms.has_value()) {
+      max_ce_delay = std::max(max_ce_delay, ue.max_ce_delay_ms.value());
+    }
+    if (ue.max_pucch_harq_delay_ms.has_value()) {
+      max_pucch_delay = std::max(max_pucch_delay, ue.max_pucch_harq_delay_ms.value());
+    }
+    if (ue.max_pusch_harq_delay_ms.has_value()) {
+      max_pusch_delay = std::max(max_pusch_delay, ue.max_pusch_harq_delay_ms.value());
+    }
   }
 
   // log cell-wide metrics
   fmt::format_to(std::back_inserter(buffer), "Cell Scheduler Metrics:");
   fmt::format_to(
       std::back_inserter(buffer),
       " total_dl_brate={}bps total_ul_brate={}bps nof_prbs={} nof_dl_slots={} nof_ul_slots={} error_indications={} "
-      "mean_latency={}usec latency_hist=[{}]",
+      "pdsch_rbs_per_slot={} pusch_rbs_per_slot={} mean_latency={}usec max_latency={}usec max_latency_slot={} "
+      "latency_hist=[{}]",
       float_to_eng_string(sum_dl_bitrate_kbps * 1e3, 1, false),
       float_to_eng_string(sum_ul_bitrate_kbps * 1e3, 1, false),
       metrics.nof_prbs,
       metrics.nof_dl_slots,
       metrics.nof_ul_slots,
       metrics.nof_error_indications,
+      sum_pdsch_rbs / metrics.nof_dl_slots,
+      sum_pusch_rbs / metrics.nof_ul_slots,
       metrics.average_decision_latency.count(),
+      metrics.max_decision_latency.count(),
+      metrics.max_decision_latency_slot,
       fmt::join(metrics.latency_histogram.begin(), metrics.latency_histogram.end(), ", "));
+  if (max_crc_delay != std::numeric_limits<float>::min()) {
+    fmt::format_to(std::back_inserter(buffer), " max_crc_delay={}ms", max_crc_delay);
+  }
+  if (max_ce_delay != std::numeric_limits<float>::min()) {
+    fmt::format_to(std::back_inserter(buffer), " max_ce_delay={}ms", max_ce_delay);
+  }
+  if (max_pucch_delay != std::numeric_limits<float>::min()) {
+    fmt::format_to(std::back_inserter(buffer), " max_pucch_harq_delay={}ms", max_pucch_delay);
+  }
+  if (max_pusch_delay != std::numeric_limits<float>::min()) {
+    fmt::format_to(std::back_inserter(buffer), " max_pusch_harq_delay={}ms", max_pusch_delay);
+  }
   if (not metrics.events.empty()) {
     fmt::format_to(std::back_inserter(buffer), " events=[");
     bool first = true;
@@ -432,7 +473,7 @@ void scheduler_cell_metrics_consumer_log::handle_metric(const app_services::metr
                    " dl_error_rate={}%",
                    dl_total > 0 ? to_percentage<int>(ue.dl_nof_nok, dl_total) : 0);
     fmt::format_to(std::back_inserter(buffer), " dl_bs={}", scaled_fmt_integer(ue.dl_bs, false));
-    fmt::format_to(std::back_inserter(buffer), " dl_nof_prbs={}", ue.tot_dl_prbs_used);
+    fmt::format_to(std::back_inserter(buffer), " dl_nof_prbs={}", ue.tot_pdsch_prbs_used);
     if (ue.last_dl_olla.has_value()) {
       fmt::format_to(std::back_inserter(buffer), " dl_olla={}", ue.last_dl_olla);
     }
@@ -456,7 +497,7 @@ void scheduler_cell_metrics_consumer_log::handle_metric(const app_services::metr
     if (ue.ul_ri_stats.get_nof_observations() > 0) {
       fmt::format_to(std::back_inserter(buffer), " ul_ri={:.1f}", ue.ul_ri_stats.get_mean());
     } else {
-      fmt::format_to(std::back_inserter(buffer), " ul_ri=n/a");
+      fmt::format_to(std::back_inserter(buffer), " ul_ri=1");
     }
 
     fmt::format_to(std::back_inserter(buffer), " ul_mcs={}", ue.ul_mcs.to_uint());
@@ -470,81 +511,38 @@ void scheduler_cell_metrics_consumer_log::handle_metric(const app_services::metr
     fmt::format_to(std::back_inserter(buffer), " ul_nof_nok={}", ue.ul_nof_nok);
 
     unsigned ul_total = ue.ul_nof_ok + ue.ul_nof_nok;
-    fmt::format_to(std::back_inserter(buffer),
-                   " ul_error_rate={}%",
-                   ul_total > 0 ? to_percentage<int>(ue.ul_nof_nok, ul_total) : 0);
-    if (ul_total > 0) {
-      fmt::format_to(std::back_inserter(buffer), " avg_crc_delay={:.3}ms", ue.avg_crc_delay_ms);
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " avg_crc_delay=n/a");
-    }
-    fmt::format_to(std::back_inserter(buffer), " ul_nof_prbs={}", ue.tot_ul_prbs_used);
-    fmt::format_to(std::back_inserter(buffer), " bsr={}", scaled_fmt_integer(ue.bsr, false));
-    fmt::format_to(std::back_inserter(buffer), " sr_count={}", ue.sr_count);
-    fmt::format_to(std::back_inserter(buffer), " f0f1_invalid_harqs={}", ue.nof_pucch_f0f1_invalid_harqs);
-    fmt::format_to(std::back_inserter(buffer), " f2f3f4_invalid_harqs={}", ue.nof_pucch_f2f3f4_invalid_harqs);
-    fmt::format_to(std::back_inserter(buffer), " f2f3f4_invalid_csis={}", ue.nof_pucch_f2f3f4_invalid_csis);
-    fmt::format_to(std::back_inserter(buffer), " pusch_invalid_harqs={}", ue.nof_pusch_invalid_harqs);
-    fmt::format_to(std::back_inserter(buffer), " pusch_invalid_csis={}", ue.nof_pusch_invalid_csis);
+    auto     out_it   = std::back_inserter(buffer);
+    fmt::format_to(out_it, " ul_error_rate={}%", ul_total > 0 ? to_percentage<int>(ue.ul_nof_nok, ul_total) : 0);
+    fmt::format_to(out_it, " ul_nof_prbs={}", ue.tot_pusch_prbs_used);
+    fmt::format_to(out_it, " bsr={}", scaled_fmt_integer(ue.bsr, false));
+    fmt::format_to(out_it, " sr_count={}", ue.sr_count);
+    fmt::format_to(out_it, " f0f1_invalid_harqs={}", ue.nof_pucch_f0f1_invalid_harqs);
+    fmt::format_to(out_it, " f2f3f4_invalid_harqs={}", ue.nof_pucch_f2f3f4_invalid_harqs);
+    fmt::format_to(out_it, " f2f3f4_invalid_csis={}", ue.nof_pucch_f2f3f4_invalid_csis);
+    fmt::format_to(out_it, " pusch_invalid_harqs={}", ue.nof_pusch_invalid_harqs);
+    fmt::format_to(out_it, " pusch_invalid_csis={}", ue.nof_pusch_invalid_csis);
     if (ue.last_ul_olla.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " ul_olla={}", ue.last_ul_olla.value());
+      fmt::format_to(out_it, " ul_olla={}", ue.last_ul_olla.value());
     }
     if (ue.ta_stats.get_nof_observations() > 0) {
-      fmt::format_to(std::back_inserter(buffer), " ta={}s", float_to_eng_string(ue.ta_stats.get_mean(), 0, false));
+      fmt::format_to(out_it, " ta={}s", float_to_eng_string(ue.ta_stats.get_mean(), 0, false));
     } else {
-      fmt::format_to(std::back_inserter(buffer), " ta=n/a");
+      fmt::format_to(out_it, " ta=n/a");
     }
     if (ue.srs_ta_stats.get_nof_observations() > 0) {
-      fmt::format_to(
-          std::back_inserter(buffer), " srs_ta={}s", float_to_eng_string(ue.srs_ta_stats.get_mean(), 0, false));
+      fmt::format_to(out_it, " srs_ta={}s", float_to_eng_string(ue.srs_ta_stats.get_mean(), 0, false));
     } else {
-      fmt::format_to(std::back_inserter(buffer), " srs_ta=n/a");
-    }
-    if (ue.last_phr.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " last_phr={}", ue.last_phr.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " last_phr=n/a");
-    }
-    if (ue.avg_ce_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " avg_ul_ce_delay={:.2}ms", ue.avg_ce_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " avg_ul_ce_delay=n/a");
-    }
-    if (ue.max_ce_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " max_ul_ce_delay={:.2}ms", ue.max_ce_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " max_ul_ce_delay=n/a");
-    }
-    if (ue.avg_crc_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " avg_crc_delay={:.2}ms", ue.avg_crc_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " avg_crc_delay=n/a");
-    }
-    if (ue.max_crc_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " max_crc_delay={:.2}ms", ue.max_crc_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " max_crc_delay=n/a");
-    }
-    if (ue.avg_pusch_harq_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " avg_pusch_harq_delay={:.2}ms", ue.avg_pusch_harq_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " avg_pusch_harq_delay=n/a");
-    }
-    if (ue.max_pusch_harq_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " max_pusch_harq_delay={:.2}ms", ue.max_pusch_harq_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " max_pusch_harq_delay=n/a");
-    }
-    if (ue.avg_pucch_harq_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " avg_pucch_harq_delay={:.2}ms", ue.avg_pucch_harq_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " avg_pucch_harq_delay=n/a");
-    }
-    if (ue.max_pucch_harq_delay_ms.has_value()) {
-      fmt::format_to(std::back_inserter(buffer), " max_pucch_harq_delay={:.2}ms", ue.max_pucch_harq_delay_ms.value());
-    } else {
-      fmt::format_to(std::back_inserter(buffer), " max_pucch_harq_delay=n/a");
-    }
+      fmt::format_to(out_it, " srs_ta=n/a");
+    }
+    fmt::format_to(out_it, " last_phr={}", format_value_or(ue.last_phr, "n/a"));
+    fmt::format_to(out_it, " avg_ul_ce_delay={:.3}", format_unit_or(ue.avg_ce_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " max_ul_ce_delay={:.3}", format_unit_or(ue.max_ce_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " avg_crc_delay={:.3}", format_unit_or(ue.avg_crc_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " max_crc_delay={:.3}", format_unit_or(ue.max_crc_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " avg_pusch_harq_delay={:.3}", format_unit_or(ue.avg_pusch_harq_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " max_pusch_harq_delay={:.3}", format_unit_or(ue.max_pusch_harq_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " avg_pucch_harq_delay={:.3}", format_unit_or(ue.avg_pucch_harq_delay_ms, "ms", "n/a"));
+    fmt::format_to(out_it, " max_pucch_harq_delay={:.3}", format_unit_or(ue.max_pucch_harq_delay_ms, "ms", "n/a"));
 
     log_chan("{}", to_c_str(buffer));
     buffer.clear();

apps/units/flexible_o_du/o_du_high/o_du_high_unit_factory.cpp

@@ -212,7 +212,7 @@ static mac_metrics_notifier* build_mac_du_metrics(std::vector<app_services::metr
 
   // MAC metrics.
   const app_helpers::metrics_config& metrics_config = du_hi_cfg.metrics.common_metrics_cfg;
-  if (!metrics_config.json_config.enable_json_metrics) {
+  if (!metrics_config.enabled()) {
     return out;
   }
 
@@ -225,8 +225,15 @@ static mac_metrics_notifier* build_mac_du_metrics(std::vector<app_services::metr
   out                 = &(*mac_metric_gen);
   mac_metrics_cfg.producers.push_back(std::move(mac_metric_gen));
 
-  mac_metrics_cfg.consumers.push_back(
-      std::make_unique<mac_metrics_consumer_json>(app_helpers::fetch_json_metrics_log_channel()));
+  if (metrics_config.enable_log_metrics) {
+    mac_metrics_cfg.consumers.push_back(
+        std::make_unique<mac_metrics_consumer_log>(app_helpers::fetch_logger_metrics_log_channel()));
+  }
+
+  if (metrics_config.json_config.enable_json_metrics) {
+    mac_metrics_cfg.consumers.push_back(
+        std::make_unique<mac_metrics_consumer_json>(app_helpers::fetch_json_metrics_log_channel()));
+  }
 
   return out;
 }