ofh: add RU emulator application

Author: Pavel Harbanau

tests/integrationtests/ofh/CMakeLists.txt

@@ -12,3 +12,14 @@ add_executable(ofh_integration_test ofh_integration_test.cpp)
 target_link_libraries(ofh_integration_test srslog srsran_ru_ofh srsran_phy_support srsran_support)
 add_test(ofh_integration_test ofh_integration_test)
 set_tests_properties(ofh_integration_test PROPERTIES LABELS "tsan;NO_MEMCHECK")
+
+if (DPDK_FOUND)
+    add_executable(ru_emulator ru_emulator_cli11_schema.cpp ru_emulator.cpp)
+    target_compile_options(ru_emulator PRIVATE ${DPDK_CFLAGS})
+
+    target_link_libraries(ru_emulator srslog srsran_ofh_dpdk_ethernet
+            srsran_phy_support srsran_support hal_dpdk ${DPDK_LIBRARIES})
+
+    target_include_directories(ru_emulator PRIVATE ${CMAKE_SOURCE_DIR})
+    include_directories(${CMAKE_SOURCE_DIR}/external)
+endif (DPDK_FOUND)

tests/integrationtests/ofh/helpers.h

@@ -0,0 +1,87 @@
+/*
+ *
+ * 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/adt/span.h"
+#include "srsran/ofh/ethernet/ethernet_mac_address.h"
+#include "srsran/ran/bs_channel_bandwidth.h"
+#include "srsran/ru/ru_ofh_configuration.h"
+
+using namespace srsran;
+
+/// Helper function to convert array of port indexes to string.
+inline std::string port_ids_to_str(span<unsigned> ports)
+{
+  fmt::memory_buffer str_buffer;
+  fmt::format_to(str_buffer, "{");
+  for (unsigned i = 0, e = ports.size(); i != e; ++i) {
+    fmt::format_to(str_buffer, "{}{}", ports[i], (i == (e - 1)) ? "}" : ", ");
+  }
+  return to_string(str_buffer);
+}
+
+/// Helper function to parse list of ports provided as a string.
+inline std::vector<unsigned> parse_port_id(const std::string& port_id_str)
+{
+  std::vector<unsigned> port_ids;
+  size_t                start_pos = port_id_str.find('{');
+  size_t                end_pos   = port_id_str.find('}');
+  if (start_pos == std::string::npos || end_pos == std::string::npos) {
+    return port_ids;
+  }
+  std::string       ports_comma_separated = port_id_str.substr(start_pos + 1, end_pos - 1);
+  std::stringstream ss(ports_comma_separated);
+  int               port;
+  while (ss >> port) {
+    port_ids.push_back(port);
+    if (ss.peek() == ',' || ss.peek() == ' ') {
+      ss.ignore();
+    }
+  }
+  return port_ids;
+}
+
+/// Parses the string containing Ethernet MAC address.
+inline bool parse_mac_address(const std::string& mac_str, ether::mac_address& mac)
+{
+  std::array<unsigned, 6> data       = {};
+  int                     bytes_read = std::sscanf(
+      mac_str.c_str(), "%02x:%02x:%02x:%02x:%02x:%02x", &data[0], &data[1], &data[2], &data[3], &data[4], &data[5]);
+  if (bytes_read != ether::ETH_ADDR_LEN) {
+    fmt::print("Invalid MAC address provided: {}\n", mac_str);
+    return false;
+  }
+
+  std::copy(data.begin(), data.end(), mac.begin());
+
+  return true;
+}
+
+/// Validates the bandwidth argument provided as a user input.
+inline bool is_valid_bw(unsigned bandwidth)
+{
+  // Bandwidth cannot be less than 5MHz.
+  if (bandwidth < 5U) {
+    return false;
+  }
+
+  // Check from [5-25] in steps of 5.
+  if (bandwidth < 26U) {
+    return ((bandwidth % 5) == 0);
+  }
+
+  // Check from [30-100] in steps of 10.
+  if (bandwidth < 101U) {
+    return ((bandwidth % 10) == 0);
+  }
+
+  return false;
+}

tests/integrationtests/ofh/ofh_integration_test.cpp

@@ -9,6 +9,7 @@
  */
 
 #include "../../../lib/phy/support/resource_grid_impl.h"
+#include "helpers.h"
 #include "srsran/adt/bounded_bitset.h"
 #include "srsran/adt/circular_map.h"
 #include "srsran/ofh/ecpri/ecpri_constants.h"
@@ -102,39 +103,6 @@ class dummy_ru_error_notifier : public ru_error_notifier
 
 static test_parameters test_params;
 
-/// Helper function to convert array of port indexes to string.
-static std::string port_ids_to_str(span<unsigned> ports)
-{
-  std::stringstream ss;
-  ss << "{";
-  for (unsigned i = 0, e = ports.size() - 1; i != e; ++i) {
-    ss << ports[i] << ", ";
-  }
-  ss << ports[ports.size() - 1] << "}";
-  return ss.str();
-}
-
-/// Helper function to parse list of ports provided as a string.
-static std::vector<unsigned> parse_port_id(const std::string& port_id_str)
-{
-  std::vector<unsigned> port_ids;
-  size_t                start_pos = port_id_str.find('{');
-  size_t                end_pos   = port_id_str.find('}');
-  if (start_pos == std::string::npos || end_pos == std::string::npos) {
-    return port_ids;
-  }
-  std::string       ports_comma_separated = port_id_str.substr(start_pos + 1, end_pos - 1);
-  std::stringstream ss(ports_comma_separated);
-  int               port;
-  while (ss >> port) {
-    port_ids.push_back(port);
-    if (ss.peek() == ',' || ss.peek() == ' ') {
-      ss.ignore();
-    }
-  }
-  return port_ids;
-}
-
 /// Prints usage information of the app.
 static void usage(const char* prog)
 {
@@ -169,55 +137,6 @@ static void usage(const char* prog)
   fmt::print("\t-h Show this message\n");
 }
 
-/// Validates the bandwidth argument provided as a user input.
-static bool validate_bw(unsigned bandwidth)
-{
-  switch (bandwidth) {
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz5):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz5;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz10):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz10;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz15):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz15;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz20):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz20;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz25):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz25;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz30):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz30;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz40):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz40;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz50):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz50;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz60):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz60;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz70):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz70;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz80):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz80;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz90):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz90;
-      break;
-    case bs_channel_bandwidth_to_MHz(bs_channel_bandwidth_fr1::MHz100):
-      test_params.bw = bs_channel_bandwidth_fr1::MHz100;
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-
 /// Parses arguments of the app.
 static void parse_args(int argc, char** argv)
 {
@@ -255,9 +174,11 @@ static void parse_args(int argc, char** argv)
         break;
       case 'w':
         if (optarg != nullptr) {
-          if (!validate_bw(std::strtol(optarg, nullptr, 10))) {
+          if (!is_valid_bw(std::strtol(optarg, nullptr, 10))) {
             fmt::print("Invalid bandwidth\n");
             invalid_arg = true;
+          } else {
+            test_params.bw = MHz_to_bs_channel_bandwidth(std::strtol(optarg, nullptr, 10));
           }
         }
         break;