UCS/TOPO: Build device inventory

src/ucp/proto/proto_multi.c

@@ -58,37 +58,13 @@ ucp_proto_multi_get_avail_bw(const ucp_proto_init_params_t *params,
     return lane_perf->bandwidth * ratio;
 }
 
-static ucs_bus_id_bit_rep_t
-ucp_proto_multi_sys_dev_bus_id_key(ucs_sys_device_t sys_dev)
-{
-    ucs_sys_bus_id_t bus_id;
-
-    if (ucs_topo_get_device_bus_id(sys_dev, &bus_id) != UCS_OK) {
-        ucs_fatal("failed to get device bus id for sys_dev %d", sys_dev);
-    }
-
-    return ucs_topo_get_bus_id_bit_repr(&bus_id);
-}
-
 static int ucp_proto_multi_sys_dev_cmp(const void *pa, const void *pb,
                                        void *UCS_V_UNUSED arg)
 {
-    const ucs_sys_device_t a   = *(const ucs_sys_device_t*)pa;
-    const ucs_sys_device_t b   = *(const ucs_sys_device_t*)pb;
-    ucs_bus_id_bit_rep_t key_a = ucp_proto_multi_sys_dev_bus_id_key(a);
-    ucs_bus_id_bit_rep_t key_b = ucp_proto_multi_sys_dev_bus_id_key(b);
-    uintptr_t user_value_a, user_value_b;
-
-    /* Sort by topology identity so every rank on the node observes the same
-     * ordering regardless of local device discovery order. */
-    if (key_a != key_b) {
-        return (key_a > key_b) - (key_a < key_b);
-    }
-
-    user_value_a = ucs_topo_sys_device_get_user_value(a);
-    user_value_b = ucs_topo_sys_device_get_user_value(b);
+    ucs_sys_device_t sys_dev1 = *(const ucs_sys_device_t*)pa;
+    ucs_sys_device_t sys_dev2 = *(const ucs_sys_device_t*)pb;
 
-    return (user_value_a > user_value_b) - (user_value_a < user_value_b);
+    return ucs_topo_sys_device_cmp(sys_dev1, sys_dev2);
 }
 
 static ucp_lane_index_t ucp_proto_multi_find_max_avail_bw_lane(

src/ucs/sys/topo/base/topo.c

@@ -268,6 +268,45 @@ ucs_topo_bus_value_key_make(const ucs_sys_bus_id_t *bus_id,
     return key;
 }
 
+int ucs_topo_sys_device_cmp_nolock(ucs_sys_device_t sys_dev1,
+                                   ucs_sys_device_t sys_dev2)
+{
+    const ucs_topo_sys_device_info_t *device1, *device2;
+    ucs_bus_id_bit_rep_t bus_id1, bus_id2;
+
+    ucs_assertv(sys_dev1 < ucs_topo_global_ctx.num_devices,
+                "invalid sys_dev1: %u", sys_dev1);
+    ucs_assertv(sys_dev2 < ucs_topo_global_ctx.num_devices,
+                "invalid sys_dev2: %u", sys_dev2);
+
+    device1 = &ucs_topo_global_ctx.devices[sys_dev1];
+    device2 = &ucs_topo_global_ctx.devices[sys_dev2];
+
+    /* Compare by bus id.*/
+    bus_id1 = ucs_topo_get_bus_id_bit_repr(&device1->bus_id);
+    bus_id2 = ucs_topo_get_bus_id_bit_repr(&device2->bus_id);
+
+    if (bus_id1 != bus_id2) {
+        return (bus_id1 > bus_id2) - (bus_id1 < bus_id2);
+    }
+
+    /* Compare by user value. */
+    return (device1->user_value > device2->user_value) -
+           (device1->user_value < device2->user_value);
+}
+
+int ucs_topo_sys_device_cmp(ucs_sys_device_t sys_dev1,
+                            ucs_sys_device_t sys_dev2)
+{
+    int result;
+
+    ucs_spin_lock(&ucs_topo_global_ctx.lock);
+    result = ucs_topo_sys_device_cmp_nolock(sys_dev1, sys_dev2);
+    ucs_spin_unlock(&ucs_topo_global_ctx.lock);
+
+    return result;
+}
+
 unsigned ucs_topo_num_devices()
 {
     unsigned num_devices;
@@ -283,17 +322,16 @@ static void ucs_topo_bus_id_str(const ucs_sys_bus_id_t *bus_id, int abbreviate,
                                 char *str, size_t max)
 {
     if (abbreviate && (bus_id->domain == 0)) {
-        ucs_snprintf_safe(str, max, "%02x:%02x.%d", bus_id->bus, bus_id->slot,
-                          bus_id->function);
+        ucs_snprintf_safe(str, max, UCS_SYS_BUS_ID_ABBREVIATED_FMT,
+                          UCS_SYS_BUS_ID_ABBREVIATED_ARG(bus_id));
     } else {
-        ucs_snprintf_safe(str, max, "%04x:%02x:%02x.%d", bus_id->domain,
-                          bus_id->bus, bus_id->slot, bus_id->function);
+        ucs_snprintf_safe(str, max, UCS_SYS_BUS_ID_FMT,
+                          UCS_SYS_BUS_ID_ARG(bus_id));
     }
 }
 
-static ucs_status_t
-ucs_topo_bus_id_to_sysfs_path(const ucs_sys_bus_id_t *bus_id, char *path,
-                              size_t max)
+ucs_status_t ucs_topo_bus_id_to_sysfs_path(const ucs_sys_bus_id_t *bus_id,
+                                           char *path, size_t max)
 {
     const size_t prefix_length = strlen(UCS_TOPO_SYSFS_PCI_PREFIX);
     ucs_status_t status;
@@ -1366,44 +1404,25 @@ static void ucs_topo_release_devices()
     }
 }
 
-static ucs_topo_groups_type_t ucs_topo_groups_type_detect()
-{
-    return (ucs_arch_get_cpu_model() == UCS_CPU_MODEL_NVIDIA_VERA) ?
-                   UCS_TOPO_GROUPS_TYPE_VERA_RUBIN :
-                   UCS_TOPO_GROUPS_TYPE_UNKNOWN;
-}
-
 ucs_status_t ucs_topo_build_groups(ucs_topo_groups_t *groups_p)
 {
     ucs_status_t status;
 
+    if (ucs_arch_get_cpu_model() != UCS_CPU_MODEL_NVIDIA_VERA) {
+        /* Currently only Vera Rubin architecture supports topology groups. */
+        ucs_debug("topology groups are not supported on this architecture");
+        return UCS_ERR_UNSUPPORTED;
+    }
+
     ucs_spin_lock(&ucs_topo_global_ctx.lock);
     status = ucs_topo_build_groups_inner(ucs_topo_global_ctx.devices,
                                          ucs_topo_global_ctx.num_devices,
-                                         ucs_topo_groups_type_detect(),
                                          groups_p);
     ucs_spin_unlock(&ucs_topo_global_ctx.lock);
 
     return status;
 }
 
-static void ucs_topo_release_group(ucs_topo_group_t *group)
-{
-    ucs_array_cleanup_dynamic(&group->nics);
-    ucs_array_cleanup_dynamic(&group->gpus);
-}
-
-void ucs_topo_release_groups(ucs_topo_groups_t *groups)
-{
-    size_t i;
-
-    for (i = 0; i < ucs_array_length(&groups->groups); ++i) {
-        ucs_topo_release_group(&ucs_array_elem(&groups->groups, i));
-    }
-
-    ucs_array_cleanup_dynamic(&groups->groups);
-}
-
 ucs_global_state_t *ucs_topo_extract_state(void)
 {
     ucs_global_state_t *state;

src/ucs/sys/topo/base/topo.h

@@ -35,6 +35,18 @@ BEGIN_C_DECLS
 /* Maximal size of BDF string */
 #define UCS_SYS_BDF_NAME_MAX 16
 
+/* Bus ID string formatting */
+#define UCS_SYS_BUS_ID_FMT "%04x:%02x:%02x.%u"
+#define UCS_SYS_BUS_ID_ARG(_bus_id) \
+    (unsigned)(_bus_id)->domain, (unsigned)(_bus_id)->bus, \
+            (unsigned)(_bus_id)->slot, (unsigned)(_bus_id)->function
+
+/* Bus ID string formatting without the domain */
+#define UCS_SYS_BUS_ID_ABBREVIATED_FMT "%02x:%02x.%u"
+#define UCS_SYS_BUS_ID_ABBREVIATED_ARG(_bus_id) \
+    (unsigned)(_bus_id)->bus, (unsigned)(_bus_id)->slot, \
+            (unsigned)(_bus_id)->function
+
 /* Special values for undefined PCI identifiers */
 #define UCS_SYS_PCI_ID_VALUE_UNDEFINED 0x0000
 #define UCS_SYS_PCI_ID_UNDEFINED \
@@ -48,6 +60,7 @@ BEGIN_C_DECLS
 #define UCS_SYS_PCI_ID_FMT         "[%04x:%04x]"
 #define UCS_SYS_PCI_ID_ARG(_pci_id) ((_pci_id)->vendor), ((_pci_id)->device)
 
+
 typedef struct ucs_sys_bus_id {
     uint16_t domain;   /* range: 0 to ffff */
     uint8_t  bus;      /* range: 0 to ff */
@@ -262,6 +275,22 @@ ucs_bus_id_bit_rep_t
 ucs_topo_get_bus_id_bit_repr(const ucs_sys_bus_id_t *bus_id);
 
 
+/**
+ * Compare two system devices by their topology identity.
+ *
+ * Registered devices are ordered by PCI bus id, then by user-defined value.
+ * Device identifiers must be valid and registered (not UNKNOWN).
+ *
+ * @param [in] sys_dev1  First system device.
+ * @param [in] sys_dev2  Second system device.
+ *
+ * @return A negative value if @a sys_dev1 precedes @a sys_dev2, a positive
+ *         value if @a sys_dev2 precedes @a sys_dev1, or zero if equal.
+ */
+int ucs_topo_sys_device_cmp(ucs_sys_device_t sys_dev1,
+                            ucs_sys_device_t sys_dev2);
+
+
 /**
  * Find the distance between two system devices (in terms of latency,
  * bandwidth, hops, etc).