ofh: enhance RU emulator statistics

Author: Pavel Harbanau

tests/integrationtests/ofh/CMakeLists.txt

@@ -18,7 +18,12 @@ target_link_libraries(ofh_integration_test
 add_test(ofh_integration_test ofh_integration_test)
 set_tests_properties(ofh_integration_test PROPERTIES LABELS "tsan;NO_MEMCHECK")
 
-set (SOURCES ru_emulator_cli11_schema.cpp ru_emulator.cpp ru_emulator_socket_transceiver.cpp)
+set (SOURCES
+        ru_emulator_cli11_schema.cpp
+        ru_emulator.cpp
+        ru_emulator_rx_window_checker.cpp
+        ru_emulator_socket_transceiver.cpp
+        ru_emulator_timing_notifier.cpp)
 if (DPDK_FOUND)
     list(APPEND SOURCES ru_emulator_dpdk_transceiver.cpp)
 endif (DPDK_FOUND)

tests/integrationtests/ofh/ru_emulator.cpp

@@ -12,13 +12,26 @@
 
 #include "srsran/adt/optional.h"
 #include "srsran/ran/bs_channel_bandwidth.h"
+#include <srsran/srslog/srslog.h>
 #include <string>
 #include <vector>
 
 namespace srsran {
 
 /// RU emulator OFH configuration parameters.
 struct ru_emulator_ofh_appconfig {
+  /// T2a maximum parameter for downlink Control-Plane in microseconds.
+  std::chrono::microseconds T2a_max_cp_dl{500};
+  /// T2a minimum parameter for downlink Control-Plane in microseconds.
+  std::chrono::microseconds T2a_min_cp_dl{258};
+  /// T2a maximum parameter for uplink Control-Plane in microseconds.
+  std::chrono::microseconds T2a_max_cp_ul{500};
+  /// T2a minimum parameter for uplink Control-Plane in microseconds.
+  std::chrono::microseconds T2a_min_cp_ul{285};
+  /// T2a maximum parameter for downlink User-Plane in microseconds.
+  std::chrono::microseconds T2a_max_up{300};
+  /// T2a minimum parameter for downlink User-Plane in microseconds.
+  std::chrono::microseconds T2a_min_up{85};
   /// Ethernet network interface name or PCI bus identifier.
   std::string network_interface;
   /// RU emulator MAC address.
@@ -27,6 +40,8 @@ struct ru_emulator_ofh_appconfig {
   std::string du_mac_address;
   /// V-LAN Tag control information field.
   unsigned vlan_tag;
+  /// Promiscuous mode flag.
+  bool enable_promiscuous = false;
   /// RU Uplink ports.
   std::vector<unsigned> ru_ul_port_id = {0, 1};
   /// RU emulator operating bandwidth.

tests/integrationtests/ofh/ru_emulator_appconfig.h

@@ -18,15 +18,26 @@ using namespace srsran;
 
 static void configure_cli11_log_args(CLI::App& app, ru_emulator_log_appconfig& log_params)
 {
-  auto level_check = [](const std::string& value) -> std::string {
-    if (value == "info" || value == "debug" || value == "warning" || value == "error") {
+  /// Function to check that the log level is correct.
+  auto check_log_level = [](const std::string& value) -> std::string {
+    if (srslog::str_to_basic_level(value).has_value()) {
       return {};
     }
-    return "Log level value not supported. Accepted values [info,debug,warning,error]";
+
+    return fmt::format("Log level '{}' not supported. Accepted values [none,info,debug,warning,error]", value);
+  };
+  /// Function to convert string parameter to srslog level.
+  auto capture_log_level_function = [](srslog::basic_levels& level) {
+    return [&level](const std::string& value) {
+      auto val = srslog::str_to_basic_level(value);
+      level    = (val) ? val.value() : srslog::basic_levels::none;
+    };
   };
 
   app.add_option("--filename", log_params.filename, "Log file output path")->capture_default_str();
-  app.add_option("--level", log_params.level, "Log level")->capture_default_str()->check(level_check);
+  add_option_function<std::string>(app, " --level", capture_log_level_function(log_params.level), "Log level")
+      ->default_str(srslog::basic_level_to_string(log_params.level))
+      ->check(check_log_level);
 }
 
 static void configure_cli11_ru_emu_dpdk_args(CLI::App& app, std::optional<ru_emulator_dpdk_appconfig>& config)
@@ -71,7 +82,28 @@ static void configure_cli11_ru_emu_args(CLI::App& app, ru_emulator_ofh_appconfig
   app.add_option("--ru_mac_addr", config.ru_mac_address, "Radio Unit MAC address")->capture_default_str();
   app.add_option("--du_mac_addr", config.du_mac_address, "Distributed Unit MAC address")->capture_default_str();
   app.add_option("--vlan_tag", config.vlan_tag, "V-LAN identifier")->capture_default_str()->check(CLI::Range(1, 4094));
+  app.add_option("--enable_promiscuous", config.enable_promiscuous, "Promiscuous mode flag")->capture_default_str();
   app.add_option("--ul_port_id", config.ru_ul_port_id, "RU uplink port identifier")->capture_default_str();
+
+  // Note: For the timing parameters, worst case is 2 slots for scs 15KHz and 14 symbols. Implementation defined.
+  app.add_option("--t2a_max_cp_dl", config.T2a_max_cp_dl, "T2a maximum value for downlink Control-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
+  app.add_option("--t2a_min_cp_dl", config.T2a_min_cp_dl, "T2a minimum value for downlink Control-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
+  app.add_option("--t2a_max_cp_ul", config.T2a_max_cp_ul, "T2a maximum value for uplink Control-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
+  app.add_option("--t2a_min_cp_ul", config.T2a_min_cp_ul, "T2a minimum value for uplink Control-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
+  app.add_option("--t2a_max_up", config.T2a_max_up, "T2a maximum value for User-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
+  app.add_option("--t2a_min_up", config.T2a_min_up, "T2a minimum value for User-Plane")
+      ->capture_default_str()
+      ->check(CLI::Range(0, 1960));
 }
 
 void srsran::configure_cli11_with_ru_emulator_appconfig_schema(CLI::App& app, ru_emulator_appconfig& ru_emu_parsed_cfg)

tests/integrationtests/ofh/ru_emulator_cli11_schema.cpp

@@ -0,0 +1,110 @@
+/*
+ *
+ * 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 "ru_emulator_rx_window_checker.h"
+
+using namespace srsran;
+using namespace ofh;
+
+static constexpr unsigned OFH_MAX_NOF_SFN = 256U;
+
+/// Calculates the Open Fronthaul slot symbol point for the given symbol point. An Open Fronthaul slot symbol point is a
+/// normal one, but with the SFN values restricted to 1 Byte.
+static slot_symbol_point calculate_ofh_slot_symbol_point(slot_symbol_point symbol_point)
+{
+  // Build a new slot symbol point that manages that the SFN values in OFH is 1 byte.
+  slot_point ota_slot = symbol_point.get_slot();
+  slot_point ofh_slot(ota_slot.numerology(), ota_slot.sfn() % OFH_MAX_NOF_SFN, ota_slot.slot_index());
+
+  return {ofh_slot, symbol_point.get_symbol_index(), symbol_point.get_nof_symbols()};
+}
+
+/// Calculate the distance between the given slot symbol points in symbols.
+static int calculate_slot_symbol_point_distance(slot_symbol_point lhs, slot_symbol_point rhs)
+{
+  srsran_assert(rhs.get_numerology() == lhs.get_numerology(),
+                "Cannot calculate the distance of two slot symbol points that have different numerologies");
+  srsran_assert(rhs.get_nof_symbols() == lhs.get_nof_symbols(),
+                "Cannot calculate the distance of two slot symbol points that have a different number of symbols");
+
+  const int nof_symbols_per_slot_wrap = OFH_MAX_NOF_SFN * NOF_SUBFRAMES_PER_FRAME *
+                                        get_nof_slots_per_subframe(to_subcarrier_spacing(rhs.get_numerology())) *
+                                        rhs.get_nof_symbols();
+
+  int a = static_cast<int>(lhs.to_uint()) - static_cast<int>(rhs.to_uint());
+  if (a >= nof_symbols_per_slot_wrap / 2) {
+    return a - nof_symbols_per_slot_wrap;
+  }
+  if (a < -nof_symbols_per_slot_wrap / 2) {
+    return a + nof_symbols_per_slot_wrap;
+  }
+  return a;
+}
+
+void ru_emulator_rx_window_checker::on_new_symbol(ofh::slot_symbol_point symbol_point)
+{
+  // Build a new slot symbol point that manages that the SFN values in OFH is 1 byte.
+  slot_symbol_point ota_symbol_point = calculate_ofh_slot_symbol_point(symbol_point);
+
+  // Update the stored slot symbol point as system value.
+  count_val.store(ota_symbol_point.to_uint(), std::memory_order_release);
+}
+
+void ru_emulator_rx_window_checker::update_rx_window_statistics(ofh::slot_symbol_point symbol_point)
+{
+  // Store the ota symbol point to use the same value for the early and late points.
+  slot_symbol_point ota_point(
+      symbol_point.get_numerology(), count_val.load(std::memory_order_acquire), symbol_point.get_nof_symbols());
+
+  // Calculate the distance between the 2 slot symbol points in symbols.
+  int diff = calculate_slot_symbol_point_distance(symbol_point, ota_point);
+
+  // Late detected.
+  if (diff > static_cast<int>(timing_parameters.sym_end)) {
+    statistics.increment_early_counter();
+    return;
+  }
+
+  // Early detected.
+  if (diff < static_cast<int>(timing_parameters.sym_start)) {
+    statistics.increment_late_counter();
+    return;
+  }
+
+  // On time detected.
+  statistics.increment_on_time_counter();
+}
+
+ru_emulator_rx_kpis ru_emulator_rx_window_checker::get_statistics()
+{
+  return statistics.get_statistics();
+}
+
+ru_emulator_rx_kpis ru_emulator_rx_window_checker::rx_window_checker_statistics::get_statistics()
+{
+  ru_emulator_rx_kpis kpis;
+
+  // Fetch the data.
+  uint64_t current_nof_on_time = nof_on_time_messages();
+  uint64_t current_nof_late    = nof_late_messages();
+  uint64_t current_nof_early   = nof_early_messages();
+
+  // Calculate the difference since last print.
+  kpis.rx_on_time = current_nof_on_time - last_on_time_value_printed;
+  kpis.rx_early   = current_nof_early - last_early_value_printed;
+  kpis.rx_late    = current_nof_late - last_late_value_printed;
+
+  // Update last print.
+  last_late_value_printed    = current_nof_late;
+  last_early_value_printed   = current_nof_early;
+  last_on_time_value_printed = current_nof_on_time;
+
+  return kpis;
+}

tests/integrationtests/ofh/ru_emulator_rx_window_checker.cpp

@@ -0,0 +1,79 @@
+/*
+ *
+ * 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/ofh/receiver/ofh_receiver_timing_parameters.h"
+#include "srsran/ofh/timing/ofh_ota_symbol_boundary_notifier.h"
+#include "srsran/srslog/logger.h"
+#include <atomic>
+
+namespace srsran {
+
+/// Helper structure with aggregated reception window statistics.
+struct ru_emulator_rx_kpis {
+  uint64_t rx_on_time;
+  uint64_t rx_late;
+  uint64_t rx_early;
+};
+
+/// \brief Reception window checker.
+///
+/// Checks if the given slot and symbol is within the reception window or not and stores the statistics.
+class ru_emulator_rx_window_checker : public ofh::ota_symbol_boundary_notifier
+{
+  /// Helper class that represents the reception window statistics.
+  class rx_window_checker_statistics
+  {
+    std::atomic<uint64_t> on_time_counter{0};
+    std::atomic<uint64_t> early_counter{0};
+    std::atomic<uint64_t> late_counter{0};
+    uint64_t              last_on_time_value_printed = 0U;
+    uint64_t              last_early_value_printed   = 0U;
+    uint64_t              last_late_value_printed    = 0U;
+
+  public:
+    /// Returns the statistics collected from the last time this function was called.
+    ru_emulator_rx_kpis get_statistics();
+
+    /// Functions to increment the counters.
+    void increment_on_time_counter() { on_time_counter.fetch_add(1, std::memory_order_relaxed); }
+    void increment_early_counter() { early_counter.fetch_add(1, std::memory_order_relaxed); }
+    void increment_late_counter() { late_counter.fetch_add(1, std::memory_order_relaxed); }
+
+    /// Getters to the message counters.
+    uint64_t nof_on_time_messages() const { return on_time_counter.load(std::memory_order_relaxed); }
+    uint64_t nof_early_messages() const { return early_counter.load(std::memory_order_relaxed); }
+    uint64_t nof_late_messages() const { return late_counter.load(std::memory_order_relaxed); }
+  };
+
+  const ofh::rx_window_timing_parameters timing_parameters;
+  rx_window_checker_statistics           statistics;
+  std::atomic<uint32_t>                  count_val;
+
+public:
+  explicit ru_emulator_rx_window_checker(ofh::rx_window_timing_parameters params) : timing_parameters(params) {}
+
+  // See interface for documentation.
+  void on_new_symbol(ofh::slot_symbol_point symbol_point) override;
+
+  /// Updates the Rx window statistics.
+  void update_rx_window_statistics(ofh::slot_symbol_point symbol_point);
+
+  /// Getters to the number of messages.
+  uint64_t nof_on_time_messages() const { return statistics.nof_on_time_messages(); }
+  uint64_t nof_early_messages() const { return statistics.nof_early_messages(); }
+  uint64_t nof_late_messages() const { return statistics.nof_late_messages(); }
+
+  /// Returns the statistics collected from the last time this function was called.
+  ru_emulator_rx_kpis get_statistics();
+};
+
+} // namespace srsran