UCP/CORE: Add unit tests for NET_DEVICES

Author: guy-ealey-morag

src/ucp/core/ucp_context.c

@@ -1031,8 +1031,7 @@ static uint64_t ucp_str_array_search_in_ranges(const char **array,
         n = 0;
         if (sscanf(p, "[%lu-%lu]%n", &range_start, &range_end, &n) != 2 ||
             n == 0 || p[n] != '\0' || range_start > range_end) {
-            ucs_warn("invalid device range: %s", array[i]);
-            continue;
+            continue; /* Invalid range */
         }
 
         str_id = strtoul(str + prefix_len, &endptr, 10);

test/gtest/ucp/test_ucp_context.cc

@@ -5,7 +5,11 @@
 */
 
 #include "ucp_test.h"
+
+#include <set>
+
 extern "C" {
+#include <ucp/core/ucp_context.h>
 #include <ucs/sys/sys.h>
 }
 
@@ -118,3 +122,272 @@ UCS_TEST_P(test_ucp_version, version_string) {
 }
 
 UCP_INSTANTIATE_TEST_CASE_TLS(test_ucp_version, all, "all")
+
+class test_ucp_net_devices_config : public ucp_test {
+public:
+    static void get_test_variants(std::vector<ucp_test_variant> &variants) {
+        add_variant(variants, UCP_FEATURE_TAG);
+    }
+
+protected:
+    /* Iterate over all network devices and apply action to each */
+    template<typename Action>
+    static void for_each_net_device(const entity &e, Action action) {
+        ucp_context_h ctx = e.ucph();
+        for (ucp_rsc_index_t i = 0; i < ctx->num_tls; ++i) {
+            const uct_tl_resource_desc_t *rsc = &ctx->tl_rscs[i].tl_rsc;
+            if (rsc->dev_type == UCT_DEVICE_TYPE_NET) {
+                action(rsc);
+            }
+        }
+    }
+
+    /* Get all mlx5 network device names from the context */
+    static std::set<std::string> get_mlx5_device_names(const entity &e) {
+        std::set<std::string> device_names;
+        for_each_net_device(e, [&](const uct_tl_resource_desc_t *rsc) {
+            if (strncmp(rsc->dev_name, "mlx5_", 5) == 0) {
+                device_names.insert(rsc->dev_name);
+            }
+        });
+        return device_names;
+    }
+
+    /* Get a list of all mlx5 device base names (without port suffix) */
+    static std::set<std::string>
+    get_mlx5_base_names(const std::set<std::string> &mlx5_devices) {
+        std::set<std::string> base_names;
+
+        for (const std::string &dev_name : mlx5_devices) {
+            size_t colon_pos = dev_name.find(':');
+            if (colon_pos != std::string::npos) {
+                base_names.insert(dev_name.substr(0, colon_pos));
+            } else {
+                base_names.insert(dev_name);
+            }
+        }
+
+        return base_names;
+    }
+
+    /* Count mlx5 resources matching a device name prefix */
+    static size_t
+    count_mlx5_resources_with_prefix(const std::set<std::string> &mlx5_devices,
+                                     const std::string &prefix) {
+        size_t count = 0;
+
+        for (const std::string &dev_name : mlx5_devices) {
+            if (dev_name.compare(0, prefix.length(), prefix) == 0) {
+                ++count;
+            }
+        }
+
+        return count;
+    }
+
+    /* Check if a specific device name exists in the set */
+    static bool has_device(const std::set<std::string> &devices,
+                           const std::string &dev_name) {
+        return devices.find(dev_name) != devices.end();
+    }
+};
+
+/*
+ * Test that when UCX_NET_DEVICES is set to a base name (e.g., "mlx5_0"),
+ * devices with the default port suffix ":1" are selected.
+ */
+UCS_TEST_P(test_ucp_net_devices_config, base_name_selects_default_port)
+{
+    entity *e = create_entity();
+
+    std::set<std::string> mlx5_devices = get_mlx5_device_names(*e);
+    if (mlx5_devices.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 network device available");
+    }
+
+    std::set<std::string> base_names = get_mlx5_base_names(mlx5_devices);
+    if (base_names.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 devices with port suffix found");
+    }
+
+    /* Pick the first base name for testing */
+    std::string test_base_name = *base_names.begin();
+
+    m_entities.clear();
+
+    /* Now create a new context with NET_DEVICES set to the base name */
+    modify_config("NET_DEVICES", test_base_name.c_str());
+    e = create_entity();
+
+    /* Verify that devices matching the base name were selected */
+    std::set<std::string> selected_devices = get_mlx5_device_names(*e);
+    size_t count = count_mlx5_resources_with_prefix(selected_devices, test_base_name);
+    EXPECT_GT(count, 0) << "Expected at least one device with base name '"
+                        << test_base_name << "' to be selected";
+
+    std::string expected_dev = test_base_name + ":1";
+    EXPECT_TRUE(has_device(selected_devices, expected_dev))
+            << "Device '" << expected_dev << "' should be selected when "
+            << "UCX_NET_DEVICES=" << test_base_name;
+}
+
+/*
+ * Test that explicit port suffix specification works correctly.
+ */
+UCS_TEST_P(test_ucp_net_devices_config, explicit_port_suffix)
+{
+    entity *e = create_entity();
+
+    std::set<std::string> mlx5_devices = get_mlx5_device_names(*e);
+    if (mlx5_devices.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 network device available");
+    }
+
+    /* Find a device with port suffix (contains ':') */
+    std::string test_dev_name = *mlx5_devices.begin();
+    ASSERT_NE(test_dev_name.find(':'), std::string::npos)
+            << "No port suffix found in device name";
+
+    m_entities.clear();
+
+    /* Create context with explicit device:port specification */
+    modify_config("NET_DEVICES", test_dev_name.c_str());
+    e = create_entity();
+
+    /* Verify the specific device was selected */
+    std::set<std::string> selected_devices = get_mlx5_device_names(*e);
+    EXPECT_TRUE(has_device(selected_devices, test_dev_name))
+        << "Device '" << test_dev_name << "' should be selected";
+}
+
+/*
+ * Test that device name range specification works with base names.
+ * E.g., "mlx5_[0-1]" should match mlx5_0:1 and mlx5_1:1
+ */
+UCS_TEST_P(test_ucp_net_devices_config, range_with_base_names)
+{
+    entity *e = create_entity();
+
+    std::set<std::string> mlx5_devices = get_mlx5_device_names(*e);
+    if (mlx5_devices.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 network device available");
+    }
+
+    size_t num_mlx5_devices = mlx5_devices.size();
+    if (num_mlx5_devices < 2) {
+        UCS_TEST_SKIP_R("Need at least 2 mlx5 devices for range test");
+    }
+
+    m_entities.clear();
+
+    /* Use a range that should match all mlx devices */
+    modify_config("NET_DEVICES", "mlx5_[0-99]");
+    e = create_entity();
+
+    /* Verify that mlx5 devices were selected */
+    std::set<std::string> selected_devices = get_mlx5_device_names(*e);
+    EXPECT_EQ(selected_devices.size(), num_mlx5_devices)
+            << "Expected " << num_mlx5_devices
+            << " mlx5 devices to be selected with range";
+}
+
+/*
+ * Test that specifying a device multiple times (e.g., via range and explicit)
+ * produces a warning about duplicate device specification.
+ */
+UCS_TEST_P(test_ucp_net_devices_config, duplicate_device_warning)
+{
+    entity *e = create_entity();
+
+    std::set<std::string> mlx5_devices = get_mlx5_device_names(*e);
+    if (mlx5_devices.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 network device available");
+    }
+
+    std::set<std::string> base_names = get_mlx5_base_names(mlx5_devices);
+    if (base_names.empty()) {
+        UCS_TEST_SKIP_R("No mlx5 devices with port suffix found");
+    }
+
+    /* Pick the first base name for testing */
+    std::string test_base_name = *base_names.begin();
+
+    m_entities.clear();
+
+    /* Set NET_DEVICES to include both a range and an explicit device that
+     * overlaps with the range, e.g., "mlx5_[0-99],mlx5_0" */
+    std::string devices_config = "mlx5_[0-99]," + test_base_name;
+    modify_config("NET_DEVICES", devices_config.c_str());
+
+    size_t warn_count;
+    {
+        scoped_log_handler slh(hide_warns_logger);
+        warn_count = m_warnings.size();
+        create_entity();
+    }
+
+    /* Check that a warning about duplicate device was printed */
+    std::string expected_warn = "device '" + test_base_name +
+                                "' is specified multiple times";
+    bool found_warning        = false;
+    for (size_t i = warn_count; i < m_warnings.size(); ++i) {
+        if (m_warnings[i].find(expected_warn) != std::string::npos) {
+            found_warning = true;
+            break;
+        }
+    }
+
+    EXPECT_TRUE(found_warning) << "Expected warning about duplicate device '"
+                               << test_base_name << "'";
+}
+
+/*
+ * Test that non-mlx devices are not affected by the mlx default port logic.
+ */
+UCS_TEST_P(test_ucp_net_devices_config, non_mlx_device_unaffected)
+{
+    std::string devices_list;
+    std::set<std::string> non_mlx_devices;
+
+    entity *e = create_entity();
+
+    std::set<std::string> mlx5_devices = get_mlx5_device_names(*e);
+
+    /* Find all non-mlx network devices */
+    for_each_net_device(*e, [&](const uct_tl_resource_desc_t *rsc) {
+        if (!has_device(mlx5_devices, rsc->dev_name)) {
+            non_mlx_devices.insert(rsc->dev_name);
+        }
+    });
+
+    if (non_mlx_devices.empty()) {
+        GTEST_SKIP() << "No non-mlx network devices available";
+    }
+
+    /* Build comma-separated list of all non-mlx devices */
+    for (const std::string &dev : non_mlx_devices) {
+        if (!devices_list.empty()) {
+            devices_list += ",";
+        }
+        devices_list += dev;
+    }
+
+    m_entities.clear();
+
+    /* Create context with all non-mlx devices */
+    modify_config("NET_DEVICES", devices_list.c_str());
+    e = create_entity();
+
+    /* Verify all devices were selected */
+    std::set<std::string> selected_devices;
+    for_each_net_device(*e, [&](const uct_tl_resource_desc_t *rsc) {
+        selected_devices.insert(rsc->dev_name);
+    });
+
+    for (const std::string &dev : non_mlx_devices) {
+        EXPECT_TRUE(has_device(selected_devices, dev))
+                << "Non-mlx device '" << dev << "' should be selected";
+    }
+}
+
+UCP_INSTANTIATE_TEST_CASE_TLS(test_ucp_net_devices_config, all, "all")