Make BDF method as default for UUID calculation

This patch makes PCIE BDF as the default method for UUID
calculation.

Related-To: LOCI-2909

Signed-off-by: Joshua Santosh Ranjan <joshua.santosh.ranjan@intel.com>

Author: joshuaranjan

level_zero/core/test/unit_tests/sources/device/linux/test_device_uuid.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -26,6 +26,7 @@ namespace ult {
 struct TestDeviceUuid : public ::testing::Test {
     void SetUp() override {}
     void TearDown() override {}
+    DebugManagerStateRestore restorer;
 };
 
 HWTEST2_F(TestDeviceUuid, GivenCorrectTelemetryNodesAreAvailableWhenRetrievingDeviceAndSubDevicePropertiesThenCorrectUuidIsReceived, IsXEHP) {
@@ -82,7 +83,7 @@ HWTEST2_F(TestDeviceUuid, GivenCorrectTelemetryNodesAreAvailableWhenRetrievingDe
 
         return -1;
     });
-    DebugManagerStateRestore restore;
+    DebugManager.flags.EnableChipsetUniqueUUID.set(1);
     DebugManager.flags.CreateMultipleSubDevices.set(2);
 
     std::unique_ptr<Mock<L0::DriverHandleImp>> driverHandle;
@@ -132,5 +133,23 @@ HWTEST2_F(TestDeviceUuid, GivenCorrectTelemetryNodesAreAvailableWhenRetrievingDe
     EXPECT_TRUE(0 == std::memcmp(deviceProps.uuid.id, expectedUuid, sizeof(expectedUuid)));
 }
 
+TEST_F(TestDeviceUuid, GivenEnableChipsetUniqueUuidIsSetWhenOsInterfaceIsNotSetThenUuidOfFallbackPathIsReceived) {
+
+    DebugManager.flags.EnableChipsetUniqueUUID.set(1);
+    auto neoDevice = NEO::MockDevice::createWithNewExecutionEnvironment<NEO::MockDevice>(NEO::defaultHwInfo.get());
+    NEO::DeviceVector devices;
+    devices.push_back(std::unique_ptr<NEO::Device>(neoDevice));
+    auto driverHandle = std::make_unique<Mock<L0::DriverHandleImp>>();
+    driverHandle->initialize(std::move(devices));
+    auto device = driverHandle->devices[0];
+
+    ze_device_properties_t deviceProperties, devicePropertiesBefore;
+    deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+    memset(&deviceProperties.uuid, std::numeric_limits<int>::max(), sizeof(deviceProperties.uuid));
+    devicePropertiesBefore = deviceProperties;
+    EXPECT_EQ(ZE_RESULT_SUCCESS, device->getProperties(&deviceProperties));
+    EXPECT_NE(0, memcmp(&deviceProperties.uuid, &devicePropertiesBefore.uuid, sizeof(devicePropertiesBefore.uuid)));
+}
+
 } // namespace ult
 } // namespace L0

opencl/test/unit_test/test_files/igdrcl.config

@@ -368,4 +368,5 @@ UseDrmCompletionFenceForAllAllocations = -1
 ExperimentalEnableSourceLevelDebugger = 0
 Force2dImageAsArray = -1
 ForceExtendedBufferSize = -1
-MakeIndirectAllocationsResidentAsPack = -1
+MakeIndirectAllocationsResidentAsPack = -1
+EnableChipsetUniqueUUID = -1

shared/source/debug_settings/debug_variables_base.inl

@@ -344,6 +344,7 @@ DECLARE_DEBUG_VARIABLE(int32_t, OverrideSystolicInComputeWalker, -1, "set SYSTOL
 DECLARE_DEBUG_VARIABLE(int32_t, AddStatePrefetchCmdToMemoryPrefetchAPI, -1, "Add STATE_PREFETCH to zeCommandListAppendMemoryPrefetch, -1:default, 0:disable, 1:enable")
 DECLARE_DEBUG_VARIABLE(int32_t, EnableDrmCompletionFence, -1, "Enables DRM completion fence, -1:default (disabled), 0:disable, 1:enable")
 DECLARE_DEBUG_VARIABLE(int32_t, UseDrmCompletionFenceForAllAllocations, -1, "Uses DRM completion fence for all allocations, -1:default (disabled), 0:disable, 1:enable")
+DECLARE_DEBUG_VARIABLE(int32_t, EnableChipsetUniqueUUID, -1, "Enables retrieving chipset unique UUID using telemetry, -1:default (disabled), 0:disable, 1:enable")
 
 /*EXPERIMENTAL TOGGLES*/
 DECLARE_DEBUG_VARIABLE(int32_t, ExperimentalSetWalkerPartitionCount, 0, "Experimental implementation: Set number of COMPUTE_WALKERs for a given Partition Type, 0 - do not set the feature.")

shared/source/device/device.cpp

@@ -270,7 +270,11 @@ bool Device::createDeviceImpl() {
     createBindlessHeapsHelper();
     if (!isEngineInstanced()) {
         auto hardwareInfo = getRootDeviceEnvironment().getMutableHardwareInfo();
-        uuid.isValid = HwInfoConfig::get(hardwareInfo->platform.eProductFamily)->getUuid(this, uuid.id);
+        uuid.isValid = false;
+
+        if (DebugManager.flags.EnableChipsetUniqueUUID.get() == 1) {
+            uuid.isValid = HwInfoConfig::get(hardwareInfo->platform.eProductFamily)->getUuid(this, uuid.id);
+        }
 
         if (!uuid.isValid && getRootDeviceEnvironment().osInterface != nullptr) {
             PhysicalDevicePciBusInfo pciBusInfo = getRootDeviceEnvironment().osInterface->getDriverModel()->getPciBusInfo();

shared/test/unit_test/os_interface/device_uuid_tests.cpp

@@ -170,4 +170,65 @@ HWTEST2_F(MultipleDeviceBdfUuidTest, GivenValidBdfWithOneBitEnabledInAffinityMas
     expectedUuid[15] = 4;
     EXPECT_TRUE(0 == std::memcmp(uuid.data(), expectedUuid, sizeof(expectedUuid)));
 }
+
+using DeviceUuidEnablementTest = MultipleDeviceBdfUuidTest;
+
+template <PRODUCT_FAMILY gfxProduct>
+class MockHwInfoConfigHwUuidEnablementTest : public HwInfoConfigHw<gfxProduct> {
+  public:
+    const bool returnStatus;
+    MockHwInfoConfigHwUuidEnablementTest(bool returnStatus) : returnStatus(returnStatus) {}
+    bool getUuid(Device *device, std::array<uint8_t, HwInfoConfig::uuidSize> &uuid) const override {
+        uuid.fill(255u);
+        return returnStatus;
+    }
+};
+
+HWTEST2_F(DeviceUuidEnablementTest, GivenEnableChipsetUniqueUUIDIsDefaultWhenDeviceIsCreatedThenChipsetUniqueUuidUsingTelemetryIsNotUsed, MatchAny) {
+
+    mockHwInfoConfig.reset(new MockHwInfoConfigHwUuidEnablementTest<productFamily>(true));
+    VariableBackup<HwInfoConfig *> backupHwInfoConfig(&hwInfoConfigFactory[productFamily], mockHwInfoConfig.get());
+    std::array<uint8_t, 16> uuid, expectedUuid;
+    uuid.fill(0u);
+    expectedUuid.fill(255u);
+
+    PhysicalDevicePciBusInfo pciBusInfo(0x00, 0x34, 0xab, 0xcd);
+    const auto deviceFactory = createDevices(pciBusInfo, 2);
+
+    EXPECT_EQ(true, deviceFactory->rootDevices[0]->getUuid(uuid));
+    EXPECT_FALSE(0 == std::memcmp(uuid.data(), expectedUuid.data(), 16));
+}
+
+HWTEST2_F(DeviceUuidEnablementTest, GivenEnableChipsetUniqueUUIDIsEnabledWhenDeviceIsCreatedThenChipsetUniqueUuidUsingTelemetryIsUsed, MatchAny) {
+
+    mockHwInfoConfig.reset(new MockHwInfoConfigHwUuidEnablementTest<productFamily>(true));
+    VariableBackup<HwInfoConfig *> backupHwInfoConfig(&hwInfoConfigFactory[productFamily], mockHwInfoConfig.get());
+    DebugManager.flags.EnableChipsetUniqueUUID.set(1);
+    std::array<uint8_t, 16> uuid, expectedUuid;
+    uuid.fill(0u);
+    expectedUuid.fill(255u);
+
+    PhysicalDevicePciBusInfo pciBusInfo(0x00, 0x34, 0xab, 0xcd);
+    const auto deviceFactory = createDevices(pciBusInfo, 2);
+
+    EXPECT_EQ(true, deviceFactory->rootDevices[0]->getUuid(uuid));
+    EXPECT_TRUE(0 == std::memcmp(uuid.data(), expectedUuid.data(), 16));
+}
+
+HWTEST2_F(DeviceUuidEnablementTest, GivenEnableChipsetUniqueUUIDIsDisabledWhenDeviceIsCreatedThenChipsetUniqueUuidUsingTelemetryIsNotUsed, MatchAny) {
+
+    mockHwInfoConfig.reset(new MockHwInfoConfigHwUuidEnablementTest<productFamily>(true));
+    VariableBackup<HwInfoConfig *> backupHwInfoConfig(&hwInfoConfigFactory[productFamily], mockHwInfoConfig.get());
+    DebugManager.flags.EnableChipsetUniqueUUID.set(0);
+    std::array<uint8_t, 16> uuid, expectedUuid;
+    uuid.fill(0u);
+    expectedUuid.fill(255u);
+
+    PhysicalDevicePciBusInfo pciBusInfo(0x00, 0x34, 0xab, 0xcd);
+    const auto deviceFactory = createDevices(pciBusInfo, 2);
+
+    EXPECT_EQ(true, deviceFactory->rootDevices[0]->getUuid(uuid));
+    EXPECT_FALSE(0 == std::memcmp(uuid.data(), expectedUuid.data(), 16));
+}
+
 } // namespace NEO