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_dev_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,52 @@ ucs_topo_bus_value_key_make(const ucs_sys_bus_id_t *bus_id,
     return key;
 }
 
+int ucs_topo_sys_dev_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_SYS_DEVICE_ID_UNKNOWN) ||
+                        (sys_dev1 < ucs_topo_global_ctx.num_devices),
+                "invalid sys_dev1: %u", sys_dev1);
+    ucs_assertv((sys_dev2 == UCS_SYS_DEVICE_ID_UNKNOWN) ||
+                        (sys_dev2 < ucs_topo_global_ctx.num_devices),
+                "invalid sys_dev2: %u", sys_dev2);
+
+    /* Unknown devices are ordered after all registered devices. */
+    if ((sys_dev1 == UCS_SYS_DEVICE_ID_UNKNOWN) ||
+        (sys_dev2 == UCS_SYS_DEVICE_ID_UNKNOWN)) {
+        return (sys_dev1 > sys_dev2) - (sys_dev1 < 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_dev_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_dev_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 +329,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;
@@ -1387,8 +1432,9 @@ ucs_status_t ucs_topo_build_groups(ucs_topo_groups_t *groups_p)
     return status;
 }
 
-static void ucs_topo_release_group(ucs_topo_group_t *group)
+void ucs_topo_release_group(ucs_topo_group_t *group)
 {
+    ucs_assert(group != NULL);
     ucs_array_cleanup_dynamic(&group->nics);
     ucs_array_cleanup_dynamic(&group->gpus);
 }
@@ -1397,6 +1443,8 @@ void ucs_topo_release_groups(ucs_topo_groups_t *groups)
 {
     size_t i;
 
+    ucs_assert(groups != NULL);
+
     for (i = 0; i < ucs_array_length(&groups->groups); ++i) {
         ucs_topo_release_group(&ucs_array_elem(&groups->groups, i));
     }

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 (abbreviated) */
+#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.
+ * @ref UCS_SYS_DEVICE_ID_UNKNOWN is ordered after all registered devices.
+ * Other device identifiers must be valid and registered.
+ *
+ * @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_dev_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).