app_unit: added the translator and factory to the CU-UP application unit

Author: AlaiaL

apps/gnb/CMakeLists.txt

@@ -22,7 +22,6 @@ install(TARGETS gnb
 target_link_libraries(gnb
         srsran_app_services
         srsgnb_app_f1u_connector
-        srsran_cu_up
         srsran_cu_cp
         srsran_network
         srsran_ngap

apps/gnb/gnb.cpp

@@ -68,6 +68,7 @@
 #include "../units/cu_cp/pcap_factory.h"
 #include "../units/cu_up/pcap_factory.h"
 #include "../units/flexible_du/du_high/pcap_factory.h"
+#include "apps/units/cu_up/cu_up_builder.h"
 #include "apps/units/flexible_du/split_dynamic/dynamic_du_unit_cli11_schema.h"
 #include "apps/units/flexible_du/split_dynamic/dynamic_du_unit_config_validator.h"
 #include "apps/units/flexible_du/split_dynamic/dynamic_du_unit_logger_registrator.h"
@@ -430,34 +431,15 @@ int main(int argc, char** argv)
     report_error("CU-CP failed to connect to AMF");
   }
 
-  // Create CU-UP config.
-  srsran::srs_cu_up::cu_up_configuration cu_up_cfg = generate_cu_up_config(cu_up_config);
-  cu_up_cfg.ctrl_executor                          = workers.cu_up_ctrl_exec;
-  cu_up_cfg.cu_up_e2_exec                          = workers.cu_up_e2_exec;
-  cu_up_cfg.ue_exec_pool                           = workers.cu_up_exec_mapper.get();
-  cu_up_cfg.io_ul_executor        = workers.cu_up_io_ul_exec; // Optionally select separate exec for UL IO
-  cu_up_cfg.e1ap.e1ap_conn_client = &e1ap_gw;
-  cu_up_cfg.f1u_gateway           = f1u_conn->get_f1u_cu_up_gateway();
-  cu_up_cfg.gtpu_pcap             = cu_up_pcaps[modules::cu_up::to_value(modules::cu_up::pcap_type::GTPU)].get();
-  cu_up_cfg.timers                = cu_timers;
-  cu_up_cfg.qos                   = generate_cu_up_qos_config(cu_up_config, du_unit_cfg.du_high_cfg.config);
-
-  // Create NG-U gateway.
-  std::unique_ptr<srs_cu_up::ngu_gateway> ngu_gw;
-  if (not cu_up_config.amf_cfg.no_core) {
-    udp_network_gateway_config ngu_gw_config = {};
-    ngu_gw_config.bind_address               = cu_up_cfg.net_cfg.n3_bind_addr;
-    ngu_gw_config.bind_port                  = cu_up_cfg.net_cfg.n3_bind_port;
-    ngu_gw_config.bind_interface             = cu_up_cfg.net_cfg.n3_bind_interface;
-    ngu_gw_config.rx_max_mmsg                = cu_up_cfg.net_cfg.n3_rx_max_mmsg;
-    ngu_gw = srs_cu_up::create_udp_ngu_gateway(ngu_gw_config, *epoll_broker, *workers.cu_up_io_ul_exec);
-  } else {
-    ngu_gw = srs_cu_up::create_no_core_ngu_gateway();
-  }
-  cu_up_cfg.ngu_gw = ngu_gw.get();
-
-  // create and start CU-UP
-  std::unique_ptr<srsran::srs_cu_up::cu_up_interface> cu_up_obj = create_cu_up(cu_up_cfg);
+  // Create and start CU-UP
+  std::unique_ptr<srs_cu_up::cu_up_interface> cu_up_obj =
+      build_cu_up(cu_up_config,
+                  workers,
+                  e1ap_gw,
+                  *f1u_conn->get_f1u_cu_up_gateway(),
+                  *cu_up_pcaps[modules::cu_up::to_value(modules::cu_up::pcap_type::GTPU)].get(),
+                  *cu_timers,
+                  *epoll_broker);
   cu_up_obj->start();
 
   std::vector<du_cell_config> du_cells = generate_du_cell_config(du_unit_cfg.du_high_cfg.config);
@@ -532,7 +514,7 @@ int main(int argc, char** argv)
 
   for (unsigned sector_id = 0, sector_end = du_inst.size(); sector_id != sector_end; ++sector_id) {
     auto& du    = du_inst[sector_id];
-    auto& upper = du->get_du_low_wrapper().get_du_low().get_upper_phy(sector_id);
+    auto& upper = du->get_du_low_wrapper().get_du_low().get_upper_phy(0);
 
     // Make connections between DU and RU.
     ru_ul_adapt.map_handler(sector_id, upper.get_rx_symbol_handler());

apps/gnb/gnb_appconfig_translators.cpp

@@ -407,25 +407,6 @@ srs_cu_cp::cu_cp_configuration srsran::generate_cu_cp_config(const du_high_unit_
   return out_cfg;
 }
 
-srs_cu_up::cu_up_configuration srsran::generate_cu_up_config(const cu_up_unit_config& config)
-{
-  srs_cu_up::cu_up_configuration out_cfg;
-  out_cfg.statistics_report_period     = std::chrono::seconds{config.metrics.cu_up_statistics_report_period};
-  out_cfg.n3_cfg.gtpu_reordering_timer = std::chrono::milliseconds{config.gtpu_reordering_timer_ms};
-  out_cfg.n3_cfg.warn_on_drop          = config.warn_on_drop;
-
-  if (config.amf_cfg.n3_bind_addr == "auto") {
-    out_cfg.net_cfg.n3_bind_addr = config.amf_cfg.bind_addr;
-  } else {
-    out_cfg.net_cfg.n3_bind_addr = config.amf_cfg.n3_bind_addr;
-  }
-  out_cfg.net_cfg.n3_ext_addr       = config.amf_cfg.n3_ext_addr;
-  out_cfg.net_cfg.n3_bind_interface = config.amf_cfg.n3_bind_interface;
-  out_cfg.net_cfg.n3_rx_max_mmsg    = config.amf_cfg.udp_rx_max_msgs;
-  out_cfg.net_cfg.f1u_bind_addr = config.amf_cfg.bind_addr; // FIXME: check if this can be removed for co-located case
-  return out_cfg;
-}
-
 static pcch_config generate_pcch_config(const du_high_unit_base_cell_config& cell)
 {
   pcch_config cfg{};
@@ -1024,52 +1005,6 @@ std::vector<du_cell_config> srsran::generate_du_cell_config(const du_high_unit_c
   return out_cfg;
 }
 
-std::map<five_qi_t, srs_cu_up::cu_up_qos_config>
-srsran::generate_cu_up_qos_config(const cu_up_unit_config& cu_up_config, const du_high_unit_config& du_cfg)
-{
-  std::map<five_qi_t, srs_cu_up::cu_up_qos_config> out_cfg = {};
-  if (cu_up_config.qos_cfg.empty()) {
-    out_cfg = config_helpers::make_default_cu_up_qos_config_list(
-        cu_up_config.warn_on_drop, timer_duration(cu_up_config.metrics.pdcp.report_period));
-    return out_cfg;
-  }
-
-  // Generate a temporary DU QoS config to obtain custom config parameters from the RLC counterpart
-  std::map<five_qi_t, du_qos_config> du_qos = generate_du_qos_config(du_cfg);
-
-  for (const auto& qos : cu_up_config.qos_cfg) {
-    if (out_cfg.find(qos.five_qi) != out_cfg.end()) {
-      report_error("Duplicate 5QI configuration: {}\n", qos.five_qi);
-    }
-    if (du_qos.find(qos.five_qi) == du_qos.end()) {
-      report_error("Cannot create CU-UP config: No entry for {} in DU QoS config\n", qos.five_qi);
-    }
-    // Convert PDCP custom config
-    pdcp_custom_config& out_pdcp_custom = out_cfg[qos.five_qi].pdcp_custom_cfg;
-    out_pdcp_custom.tx.warn_on_drop     = cu_up_config.warn_on_drop;
-    out_pdcp_custom.metrics_period      = timer_duration(cu_up_config.metrics.pdcp.report_period);
-
-    // Obtain RLC config parameters from the respective RLC mode
-    const auto& du_five_qi = du_qos[qos.five_qi];
-    if (du_five_qi.rlc.mode == rlc_mode::um_bidir) {
-      // Take from UM config
-      out_pdcp_custom.tx.rlc_sdu_queue = du_five_qi.rlc.um.tx.queue_size;
-    } else if (du_five_qi.rlc.mode == rlc_mode::am) {
-      // Take from AM config
-      out_pdcp_custom.tx.rlc_sdu_queue = du_five_qi.rlc.am.tx.queue_size;
-    } else {
-      report_error("Cannot create CU-UP config: Unsupported rlc_mode={} for {} in DU QoS config\n.",
-                   du_five_qi.rlc.mode,
-                   qos.five_qi);
-    }
-
-    // Convert F1-U config
-    srs_cu_up::f1u_config& f1u_cfg = out_cfg[qos.five_qi].f1u_cfg;
-    f1u_cfg.warn_on_drop           = cu_up_config.warn_on_drop;
-  }
-  return out_cfg;
-}
-
 static rlc_am_config generate_du_rlc_am_config(const du_high_unit_rlc_am_config& in_cfg)
 {
   rlc_am_config out_rlc;

apps/gnb/gnb_appconfig_translators.h

@@ -49,16 +49,9 @@ srsran::sctp_network_connector_config generate_ngap_nw_config(const cu_cp_unit_a
 srs_cu_cp::cu_cp_configuration generate_cu_cp_config(const du_high_unit_config& config,
                                                      const cu_cp_unit_config&   cu_cfg);
 
-/// Converts and returns the given gnb application configuration to a CU-UP configuration.
-srs_cu_up::cu_up_configuration generate_cu_up_config(const cu_up_unit_config& config);
-
 /// Converts and returns the given gnb application configuration to a DU cell configuration.
 std::vector<du_cell_config> generate_du_cell_config(const du_high_unit_config& config);
 
-/// Converts and returns the given gnb application QoS configuration to a CU-UP configuration.
-std::map<five_qi_t, srs_cu_up::cu_up_qos_config> generate_cu_up_qos_config(const cu_up_unit_config&   cu_up_config,
-                                                                           const du_high_unit_config& du_cfg);
-
 /// Converts and returns the given gnb application QoS configuration to a DU QoS list configuration.
 std::map<five_qi_t, du_qos_config> generate_du_qos_config(const du_high_unit_config& config);
 

apps/units/cu_up/CMakeLists.txt

@@ -8,8 +8,12 @@
 
 set(SOURCES
         cu_up_application_unit_impl.cpp
+        cu_up_builder.cpp
+        cu_up_unit_config_cli11_schema.cpp
+        cu_up_unit_config_translators.cpp
         cu_up_unit_config_validator.cpp
-        cu_up_unit_config_cli11_schema.cpp)
+        cu_up_wrapper.cpp)
 
 add_library(srsran_cu_up_app_unit STATIC ${SOURCES})
 target_include_directories(srsran_cu_up_app_unit PRIVATE ${CMAKE_SOURCE_DIR})
+target_link_libraries(srsran_cu_up_app_unit srsran_cu_up)

apps/units/cu_up/cu_up_builder.cpp

@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2021-2024 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.
+ *
+ */
+
+#include "cu_up_builder.h"
+#include "apps/services/worker_manager.h"
+#include "cu_up_unit_config.h"
+#include "cu_up_unit_config_translators.h"
+#include "cu_up_wrapper.h"
+#include "srsran/cu_up/cu_up_factory.h"
+
+using namespace srsran;
+
+std::unique_ptr<srs_cu_up::cu_up_interface> srsran::build_cu_up(const cu_up_unit_config&           unit_cfg,
+                                                                worker_manager&                    workers,
+                                                                srs_cu_up::e1ap_connection_client& e1ap_conn_client,
+                                                                f1u_cu_up_gateway&                 f1u_gateway,
+                                                                dlt_pcap&                          gtpu_pcap,
+                                                                timer_manager&                     timers,
+                                                                io_broker&                         io_brk)
+{
+  srs_cu_up::cu_up_configuration config = generate_cu_up_config(unit_cfg);
+  config.ctrl_executor                  = workers.cu_up_ctrl_exec;
+  config.cu_up_e2_exec                  = workers.cu_up_e2_exec;
+  config.ue_exec_pool                   = workers.cu_up_exec_mapper.get();
+  config.io_ul_executor                 = workers.cu_up_io_ul_exec; // Optionally select separate exec for UL IO
+  config.e1ap.e1ap_conn_client          = &e1ap_conn_client;
+  config.f1u_gateway                    = &f1u_gateway;
+  config.gtpu_pcap                      = &gtpu_pcap;
+  config.timers                         = &timers;
+  config.qos                            = generate_cu_up_qos_config(unit_cfg);
+
+  // Create NG-U gateway.
+  std::unique_ptr<srs_cu_up::ngu_gateway> ngu_gw;
+  if (not unit_cfg.upf_cfg.no_core) {
+    udp_network_gateway_config ngu_gw_config = {};
+    ngu_gw_config.bind_address               = config.net_cfg.n3_bind_addr;
+    ngu_gw_config.bind_port                  = config.net_cfg.n3_bind_port;
+    ngu_gw_config.bind_interface             = config.net_cfg.n3_bind_interface;
+    ngu_gw_config.rx_max_mmsg                = config.net_cfg.n3_rx_max_mmsg;
+    ngu_gw = srs_cu_up::create_udp_ngu_gateway(ngu_gw_config, io_brk, *workers.cu_up_io_ul_exec);
+  } else {
+    ngu_gw = srs_cu_up::create_no_core_ngu_gateway();
+  }
+  config.ngu_gw = ngu_gw.get();
+
+  return std::make_unique<cu_up_wrapper>(std::move(ngu_gw), create_cu_up(config));
+}

apps/units/cu_up/cu_up_builder.h

@@ -0,0 +1,37 @@
+/*
+ *
+ * Copyright 2021-2024 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 "srsran/cu_up/cu_up.h"
+#include <memory>
+
+namespace srsran {
+
+namespace srs_cu_up {
+class e1ap_connection_client;
+}
+
+struct cu_up_unit_config;
+class dlt_pcap;
+class f1u_cu_up_gateway;
+class io_broker;
+struct worker_manager;
+
+/// Builds the CU UP using the given arguments.
+std::unique_ptr<srs_cu_up::cu_up_interface> build_cu_up(const cu_up_unit_config&           unit_cfg,
+                                                        worker_manager&                    workers,
+                                                        srs_cu_up::e1ap_connection_client& e1ap_conn_client,
+                                                        f1u_cu_up_gateway&                 f1u_gateway,
+                                                        dlt_pcap&                          gtpu_pcap,
+                                                        timer_manager&                     timers,
+                                                        io_broker&                         io_brk);
+
+} // namespace srsran

apps/units/cu_up/cu_up_unit_config.h

@@ -35,7 +35,9 @@ struct cu_up_unit_upf_config {
 
 /// QoS configuration.
 struct cu_up_unit_qos_config {
-  five_qi_t five_qi = uint_to_five_qi(9);
+  five_qi_t   five_qi       = uint_to_five_qi(9);
+  std::string mode          = "am";
+  unsigned    rlc_sdu_queue = 4096;
 };
 
 /// CU-UP application unit configuration.
@@ -44,7 +46,7 @@ struct cu_up_unit_config {
   unsigned gtpu_reordering_timer_ms = 0;
   bool     warn_on_drop             = false;
   /// UPF configuration.
-  cu_up_unit_upf_config amf_cfg;
+  cu_up_unit_upf_config upf_cfg;
   /// Metrics.
   cu_up_unit_metrics_config metrics;
   /// Loggers.

apps/units/cu_up/cu_up_unit_config_cli11_schema.cpp

@@ -64,29 +64,58 @@ static void configure_cli11_metrics_args(CLI::App& app, cu_up_unit_metrics_confi
       ->capture_default_str();
 }
 
-static void configure_cli11_amf_args(CLI::App& app, cu_up_unit_upf_config& amf_params)
+static void configure_cli11_upf_args(CLI::App& app, cu_up_unit_upf_config& upf_params)
 {
   add_option(app,
              "--bind_addr",
-             amf_params.bind_addr,
+             upf_params.bind_addr,
              "Default local IP address interfaces bind to, unless a specific bind address is specified")
       ->check(CLI::ValidIPV4);
-  add_option(app, "--n3_bind_addr", amf_params.n3_bind_addr, "Local IP address to bind for N3 interface")
+  add_option(app, "--n3_bind_addr", upf_params.n3_bind_addr, "Local IP address to bind for N3 interface")
       ->check(CLI::ValidIPV4);
-  add_option(app, "--n3_bind_interface", amf_params.n3_bind_interface, "Network device to bind for N3 interface")
+  add_option(app, "--n3_bind_interface", upf_params.n3_bind_interface, "Network device to bind for N3 interface")
       ->capture_default_str();
   add_option(app,
              "--n3_ext_addr",
-             amf_params.n3_ext_addr,
+             upf_params.n3_ext_addr,
              "External IP address that is advertised to receive GTP-U packets from UPF via N3 interface")
       ->check(CLI::ValidIPV4);
-  add_option(app, "--udp_max_rx_msgs", amf_params.udp_rx_max_msgs, "Maximum amount of messages RX in a single syscall");
-  add_option(app, "--no_core", amf_params.no_core, "Allow gNB to run without a core");
+  add_option(app, "--udp_max_rx_msgs", upf_params.udp_rx_max_msgs, "Maximum amount of messages RX in a single syscall");
+  add_option(app, "--no_core", upf_params.no_core, "Allow gNB to run without a core");
+}
+
+static void configure_cli11_rlc_am_args(CLI::App& app, uint32_t& queue_size)
+{
+  CLI::App* tx_subcmd = app.add_subcommand("tx", "AM TX parameters");
+  add_option(*tx_subcmd, "--queue-size", queue_size, "RLC AM TX SDU queue size")->capture_default_str();
+}
+
+static void configure_cli11_rlc_um_args(CLI::App& app, uint32_t& queue_size)
+{
+  CLI::App* rlc_tx_um_subcmd = app.add_subcommand("tx", "UM TX parameters");
+  rlc_tx_um_subcmd->add_option("--queue-size", queue_size, "RLC UM TX SDU queue size")->capture_default_str();
+}
+
+static void configure_cli11_rlc_args(CLI::App& app, cu_up_unit_qos_config& qos_params)
+{
+  add_option(app, "--mode", qos_params.mode, "RLC mode")->capture_default_str();
+
+  // UM section.
+  CLI::App* rlc_um_subcmd = app.add_subcommand("um-bidir", "UM parameters");
+  configure_cli11_rlc_um_args(*rlc_um_subcmd, qos_params.rlc_sdu_queue);
+
+  // AM section.
+  CLI::App* rlc_am_subcmd = app.add_subcommand("am", "AM parameters");
+  configure_cli11_rlc_am_args(*rlc_am_subcmd, qos_params.rlc_sdu_queue);
 }
 
 static void configure_cli11_qos_args(CLI::App& app, cu_up_unit_qos_config& qos_params)
 {
   add_option(app, "--five_qi", qos_params.five_qi, "5QI")->capture_default_str()->check(CLI::Range(0, 255));
+
+  // RLC section.
+  CLI::App* rlc_subcmd = app.add_subcommand("rlc", "RLC parameters");
+  configure_cli11_rlc_args(*rlc_subcmd, qos_params);
 }
 
 void srsran::configure_cli11_with_cu_up_unit_config_schema(CLI::App& app, cu_up_unit_config& unit_cfg)
@@ -105,7 +134,7 @@ void srsran::configure_cli11_with_cu_up_unit_config_schema(CLI::App& app, cu_up_
 
   // AMF section.
   CLI::App* amf_subcmd = add_subcommand(app, "amf", "AMF parameters")->configurable();
-  configure_cli11_amf_args(*amf_subcmd, unit_cfg.amf_cfg);
+  configure_cli11_upf_args(*amf_subcmd, unit_cfg.upf_cfg);
 
   // QoS section.
   auto qos_lambda = [&unit_cfg](const std::vector<std::string>& values) {