Add CTS for Sysmandevicemapping to verify UUID's (#62)

  *  zesDeviceGetSubDevicePropertiesExp is used to retrieve Subdevice
       UUID's.
  * Sysman UUID's are compared with Core UUID's (FLAT Mode)

Related-To: VLCLJ-2256

Signed-off-by: Vishnu Khanth <[email protected]>

Author: vishnu-khanth

conformance_tests/sysman/test_sysman_device/src/test_sysman_device.cpp

@@ -143,6 +143,22 @@ TEST_F(
     putenv(enable_sysman_env);
   }
 }
+
+TEST_F(
+    SYSMAN_DEVICE_TEST,
+    GivenHierarchyModeFlatAndSysmanEnableEnvDisabledThenUUIDFromCoreAndSysmanMatches) {
+  auto is_sysman_enabled = getenv("ZES_ENABLE_SYSMAN");
+  // Disabling enable_sysman env if it's defaultly enabled
+  if (is_sysman_enabled != nullptr && strcmp(is_sysman_enabled, "1") == 0) {
+    char disable_sysman_env[] = "ZES_ENABLE_SYSMAN=0";
+    putenv(disable_sysman_env);
+  }
+  run_child_process("FLAT");
+  if (is_sysman_enabled != nullptr && strcmp(is_sysman_enabled, "1") == 0) {
+    char enable_sysman_env[] = "ZES_ENABLE_SYSMAN=1";
+    putenv(enable_sysman_env);
+  }
+}
 #endif // USE_ZESINIT
 
 TEST_F(

conformance_tests/sysman/test_sysman_device/src/test_sysman_device_helper.cpp

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -12,43 +12,68 @@
 
 namespace lzt = level_zero_tests;
 
-void get_sysman_devices_uuids(std::vector<zes_device_handle_t> sysman_devices,
-                              std::vector<zes_uuid_t> &sysman_device_uuids) {
-  for (const auto &sysman_device : sysman_devices) {
-    zes_device_properties_t properties = {ZES_STRUCTURE_TYPE_DEVICE_PROPERTIES};
-    zes_device_ext_properties_t ext_properties = {
-        ZES_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES};
-    properties.pNext = &ext_properties;
-    ze_result_t result = zesDeviceGetProperties(sysman_device, &properties);
-    auto sysman_device_uuid = ext_properties.uuid;
-    sysman_device_uuids.push_back(sysman_device_uuid);
+typedef std::array<uint8_t, ZE_MAX_DEVICE_UUID_SIZE> UUID;
+
+#define TO_STD_ARRAY(x)                                                        \
+  [](const uint8_t(&arr)[ZE_MAX_DEVICE_UUID_SIZE]) {                           \
+    UUID uuid;                                                                 \
+    std::copy(std::begin(arr), std::end(arr), uuid.begin());                   \
+    return uuid;                                                               \
+  }(x)
+
+UUID get_sysman_device_uuid(zes_device_handle_t sysman_device) {
+  zes_device_properties_t properties = {ZES_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+  zes_device_ext_properties_t ext_properties = {
+      ZES_STRUCTURE_TYPE_DEVICE_EXT_PROPERTIES};
+  properties.pNext = &ext_properties;
+  EXPECT_EQ(ZE_RESULT_SUCCESS,
+            zesDeviceGetProperties(sysman_device, &properties));
+  auto sysman_device_uuid = ext_properties.uuid;
+  return TO_STD_ARRAY(sysman_device_uuid.id);
+}
+
+void get_sysman_sub_devices_uuids(zes_device_handle_t sysman_device,
+                                  std::vector<UUID> &sysman_device_uuids) {
+  uint32_t num_sub_devices = 0;
+  auto sub_device_properties =
+      lzt::get_sysman_subdevice_properties(sysman_device, num_sub_devices);
+  for (uint32_t sub_device_index = 0; sub_device_index < num_sub_devices;
+       sub_device_index++) {
+    sysman_device_uuids.push_back(
+        TO_STD_ARRAY(sub_device_properties[sub_device_index].uuid.id));
   }
 }
 
-void get_ze_root_uuids(std::vector<ze_device_handle_t> ze_devices,
-                       std::vector<ze_device_uuid_t> &ze_root_uuids,
-                       char *device_hierarchy) {
-  for (const auto &ze_device : ze_devices) {
-    ze_device_handle_t ze_root_device;
-    if (strcmp(device_hierarchy, "COMBINED") == 0) {
-      ze_root_device = lzt::get_root_device(ze_device);
-      if (ze_root_device == nullptr) {
-        ze_root_device = ze_device;
-      }
-    } else if (strcmp(device_hierarchy, "COMPOSITE") == 0) {
+UUID get_ze_device_uuid(ze_device_handle_t ze_device) {
+  auto ze_device_properties = lzt::get_device_properties(ze_device);
+  auto ze_device_uuid = ze_device_properties.uuid;
+  return TO_STD_ARRAY(ze_device_uuid.id);
+}
+
+UUID get_ze_root_uuid(ze_device_handle_t ze_device, char *device_hierarchy) {
+  ze_device_handle_t ze_root_device;
+  if (strcmp(device_hierarchy, "COMBINED") == 0) {
+    ze_root_device = lzt::get_root_device(ze_device);
+    if (ze_root_device == nullptr) {
       ze_root_device = ze_device;
-    } else {
-      LOG_WARNING << "Unhandled ZE_FLAT_DEVICE_HIERARCHY mode:"
-                  << device_hierarchy;
-      continue;
-    }
-    auto root_device_properties = lzt::get_device_properties(ze_root_device);
-    auto root_uuid = root_device_properties.uuid;
-    if (std::find(ze_root_uuids.begin(), ze_root_uuids.end(), root_uuid) ==
-        ze_root_uuids.end()) {
-      ze_root_uuids.push_back(root_uuid);
     }
+  } else if (strcmp(device_hierarchy, "COMPOSITE") == 0) {
+    ze_root_device = ze_device;
+  } else {
+    LOG_WARNING << "Unhandled ZE_FLAT_DEVICE_HIERARCHY mode:"
+                << device_hierarchy;
   }
+
+  return get_ze_device_uuid(ze_root_device);
+}
+
+bool compare_core_and_sysman_uuid(std::vector<UUID> core_uuids,
+                                  std::vector<UUID> sysman_uuids) {
+  std::sort(core_uuids.begin(), core_uuids.end());
+  std::sort(sysman_uuids.begin(), sysman_uuids.end());
+  return (
+      core_uuids.size() == sysman_uuids.size() &&
+      std::equal(core_uuids.begin(), core_uuids.end(), sysman_uuids.begin()));
 }
 
 int main(int argc, char **argv) {
@@ -74,23 +99,41 @@ int main(int argc, char **argv) {
   auto sysman_devices = lzt::get_zes_devices();
   EXPECT_FALSE(sysman_devices.empty());
 
-  std::vector<zes_uuid_t> sysman_device_uuids;
-  get_sysman_devices_uuids(sysman_devices, sysman_device_uuids);
+  std::vector<UUID> sysman_device_uuids{};
+  std::vector<UUID> ze_device_uuids{};
 
-  std::vector<ze_device_uuid_t> ze_root_uuids;
-  get_ze_root_uuids(ze_devices, ze_root_uuids, device_hierarchy);
+  if (strcmp(device_hierarchy, "FLAT") != 0) { // composite or combined mode
+    for (const auto &sysman_device : sysman_devices) {
+      sysman_device_uuids.push_back(get_sysman_device_uuid(sysman_device));
+    }
 
-  for (const auto &ze_root_uuid : ze_root_uuids) {
-    bool ze_and_sysman_uuid_equal = false;
-    for (const auto &sysman_device_uuid : sysman_device_uuids) {
-      if (memcmp(ze_root_uuid.id, sysman_device_uuid.id,
-                 ZE_MAX_DEVICE_UUID_SIZE) == false) {
-        ze_and_sysman_uuid_equal = true;
-        break;
+    for (const auto &ze_device : ze_devices) {
+      auto ze_root_uuid = get_ze_root_uuid(ze_device, device_hierarchy);
+      if (std::find(ze_device_uuids.begin(), ze_device_uuids.end(),
+                    ze_root_uuid) == ze_device_uuids.end()) {
+        ze_device_uuids.push_back(ze_root_uuid);
+      }
+    }
+  } else { // flat mode
+    for (const auto &sysman_device : sysman_devices) {
+      auto device_properties = lzt::get_sysman_device_properties(sysman_device);
+      uint32_t sub_devices_count = device_properties.numSubdevices;
+      if (sub_devices_count > 0) {
+        get_sysman_sub_devices_uuids(sysman_device, sysman_device_uuids);
+      } else {
+        // if subdevice doesn't exist for a device, then root device UUID
+        // is retrieved to match with core UUID's retrieved from flat mode
+        sysman_device_uuids.push_back(get_sysman_device_uuid(sysman_device));
       }
     }
-    EXPECT_TRUE(ze_and_sysman_uuid_equal);
+
+    for (const auto &ze_device : ze_devices) {
+      ze_device_uuids.push_back(get_ze_device_uuid(ze_device));
+    }
   }
 
+  EXPECT_TRUE(
+      compare_core_and_sysman_uuid(ze_device_uuids, sysman_device_uuids));
+
   exit(0);
 }