intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-21 09:14:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature(sysman): enables uuid from zesDeviceGetProperties with zesInit

Browse Source 
Related-To: NEO-9047

Signed-off-by: Kulkarni, Ashwin Kumar <ashwin.kumar.kulkarni@intel.com>
This commit is contained in:
Kulkarni, Ashwin Kumar
2023-11-14 13:38:08 +00:00
committed by Compute-Runtime-Automation
parent e91ce78ec8
commit bf92d7824e
3 changed files with 188 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
level_zero/sysman/source/api/global_operations/windows/sysman_os_global_operations_imp.cpp
View File

@@ -7,6 +7,9 @@
#include "level_zero/sysman/source/api/global_operations/windows/sysman_os_global_operations_imp.h"
#include "shared/source/helpers/gfx_core_helper.h"
#include "shared/source/os_interface/os_interface.h"
namespace L0 {
namespace Sysman {
@@ -35,9 +38,67 @@ void WddmGlobalOperationsImp::getWedgedStatus(zes_device_state_t *pState) {
void WddmGlobalOperationsImp::getRepairStatus(zes_device_state_t *pState) {
}
bool WddmGlobalOperationsImp::getUuid(std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
return false;
if (pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironment().osInterface != nullptr) {
auto driverModel = pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironment().osInterface->getDriverModel();
if (!this->uuid.isValid) {
NEO::PhysicalDevicePciBusInfo pciBusInfo = driverModel->getPciBusInfo();
this->uuid.isValid = generateUuidFromPciBusInfo(pciBusInfo, this->uuid.id);
}
if (this->uuid.isValid) {
uuid = this->uuid.id;
}
}
return this->uuid.isValid;
}
bool WddmGlobalOperationsImp::generateUuidFromPciBusInfo(const NEO::PhysicalDevicePciBusInfo &pciBusInfo, std::array<uint8_t, NEO::ProductHelper::uuidSize> &uuid) {
if (pciBusInfo.pciDomain != NEO::PhysicalDevicePciBusInfo::invalidValue) {
uuid.fill(0);
// Device UUID uniquely identifies a device within a system.
// We generate it based on device information along with PCI information
// This guarantees uniqueness of UUIDs on a system even when multiple
// identical Intel GPUs are present.
//
// We want to have UUID matching between different GPU APIs (including outside
// of compute_runtime project - i.e. other than L0 or OCL). This structure definition
// has been agreed upon by various Intel driver teams.
//
// Consult other driver teams before changing this.
//
struct DeviceUUID {
uint16_t vendorID;
uint16_t deviceID;
uint16_t revisionID;
uint16_t pciDomain;
uint8_t pciBus;
uint8_t pciDev;
uint8_t pciFunc;
uint8_t reserved[4];
uint8_t subDeviceID;
};
auto &hwInfo = pWddmSysmanImp->getSysmanDeviceImp()->getHardwareInfo();
DeviceUUID deviceUUID = {};
deviceUUID.vendorID = 0x8086; // Intel
deviceUUID.deviceID = hwInfo.platform.usDeviceID;
deviceUUID.revisionID = hwInfo.platform.usRevId;
deviceUUID.pciDomain = static_cast<uint16_t>(pciBusInfo.pciDomain);
deviceUUID.pciBus = static_cast<uint8_t>(pciBusInfo.pciBus);
deviceUUID.pciDev = static_cast<uint8_t>(pciBusInfo.pciDevice);
deviceUUID.pciFunc = static_cast<uint8_t>(pciBusInfo.pciFunction);
deviceUUID.subDeviceID = 0;
static_assert(sizeof(DeviceUUID) == NEO::ProductHelper::uuidSize);
memcpy_s(uuid.data(), NEO::ProductHelper::uuidSize, &deviceUUID, sizeof(DeviceUUID));
return true;
}
return false;
}
ze_result_t WddmGlobalOperationsImp::reset(ze_bool_t force) {
@@ -66,7 +127,7 @@ ze_result_t WddmGlobalOperationsImp::deviceGetState(zes_device_state_t *pState)
}
WddmGlobalOperationsImp::WddmGlobalOperationsImp(OsSysman *pOsSysman) {
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
}

5
level_zero/sysman/source/api/global_operations/windows/sysman_os_global_operations_imp.h
View File

@@ -35,8 +35,13 @@ class WddmGlobalOperationsImp : public OsGlobalOperations, NEO::NonCopyableOrMov
WddmGlobalOperationsImp(OsSysman *pOsSysman);
WddmGlobalOperationsImp() = default;
~WddmGlobalOperationsImp() override = default;
struct {
bool isValid = false;
std::array<uint8_t, NEO::ProductHelper::uuidSize> id;
} uuid;
protected:
WddmSysmanImp *pWddmSysmanImp = nullptr;
KmdSysManager *pKmdSysManager = nullptr;
};

120
level_zero/sysman/test/unit_tests/sources/global_operations/windows/test_zes_global_operations.cpp
View File

@@ -5,6 +5,9 @@
*
*/
#include "shared/test/common/mocks/mock_product_helper.h"
#include "shared/test/common/test_macros/hw_test.h"
#include "level_zero/sysman/source/api/global_operations/windows/sysman_os_global_operations_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/global_operations/windows/mock_global_operations.h"
#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h"
@@ -80,6 +83,123 @@ TEST_F(SysmanGlobalOperationsFixture, GivenDeviceInUseWhenCallingzesDeviceResetE
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result);
}
class SysmanGlobalOperationsUuidFixture : public SysmanDeviceFixture {
public:
L0::Sysman::GlobalOperationsImp *pGlobalOperationsImp;
L0::Sysman::SysmanDeviceImp *device = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
pGlobalOperationsImp = static_cast<L0::Sysman::GlobalOperationsImp *>(pSysmanDeviceImp->pGlobalOperations);
device = pSysmanDeviceImp;
}
void TearDown() override {
SysmanDeviceFixture::TearDown();
}
void initGlobalOps() {
zes_device_state_t deviceState;
zesDeviceGetState(device, &deviceState);
}
};
TEST_F(SysmanGlobalOperationsUuidFixture, GivenValidDeviceHandleWhenCallingGenerateUuidFromPciBusInfoThenValidUuidIsReturned) {
initGlobalOps();
auto pHwInfo = pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironment().getMutableHardwareInfo();
pHwInfo->platform.usDeviceID = 0x1234;
pHwInfo->platform.usRevId = 0x1;
std::array<uint8_t, NEO::ProductHelper::uuidSize> uuid;
NEO::PhysicalDevicePciBusInfo pciBusInfo = {};
pciBusInfo.pciDomain = 0x5678;
pciBusInfo.pciBus = 0x9;
pciBusInfo.pciDevice = 0xA;
pciBusInfo.pciFunction = 0xB;
bool result = pGlobalOperationsImp->pOsGlobalOperations->generateUuidFromPciBusInfo(pciBusInfo, uuid);
EXPECT_EQ(true, result);
uint8_t *pUuid = (uint8_t *)uuid.data();
EXPECT_EQ(*((uint16_t *)pUuid), (uint16_t)0x8086);
EXPECT_EQ(*((uint16_t *)(pUuid + 2)), (uint16_t)pHwInfo->platform.usDeviceID);
EXPECT_EQ(*((uint16_t *)(pUuid + 4)), (uint16_t)pHwInfo->platform.usRevId);
EXPECT_EQ(*((uint16_t *)(pUuid + 6)), (uint16_t)pciBusInfo.pciDomain);
EXPECT_EQ((*(pUuid + 8)), (uint8_t)pciBusInfo.pciBus);
EXPECT_EQ((*(pUuid + 9)), (uint8_t)pciBusInfo.pciDevice);
EXPECT_EQ((*(pUuid + 10)), (uint8_t)pciBusInfo.pciFunction);
}
TEST_F(SysmanGlobalOperationsUuidFixture, GivenValidDeviceHandleWhenCallingGetUuidMultipleTimesThenSameUuidIsReturned) {
initGlobalOps();
auto pHwInfo = pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironment().getMutableHardwareInfo();
pHwInfo->platform.usDeviceID = 0x1234;
pHwInfo->platform.usRevId = 0x1;
std::array<uint8_t, NEO::ProductHelper::uuidSize> uuid = {};
bool result = pGlobalOperationsImp->pOsGlobalOperations->getUuid(uuid);
EXPECT_EQ(true, result);
uint8_t *pUuid = (uint8_t *)uuid.data();
EXPECT_EQ(*((uint16_t *)pUuid), (uint16_t)0x8086);
EXPECT_EQ(*((uint16_t *)(pUuid + 2)), (uint16_t)pHwInfo->platform.usDeviceID);
EXPECT_EQ(*((uint16_t *)(pUuid + 4)), (uint16_t)pHwInfo->platform.usRevId);
uuid = {};
result = pGlobalOperationsImp->pOsGlobalOperations->getUuid(uuid);
EXPECT_EQ(true, result);
pUuid = (uint8_t *)uuid.data();
EXPECT_EQ(*((uint16_t *)pUuid), (uint16_t)0x8086);
EXPECT_EQ(*((uint16_t *)(pUuid + 2)), (uint16_t)pHwInfo->platform.usDeviceID);
EXPECT_EQ(*((uint16_t *)(pUuid + 4)), (uint16_t)pHwInfo->platform.usRevId);
}
TEST_F(SysmanGlobalOperationsUuidFixture, GivenValidDeviceHandleWithInvalidPciDomainWhenCallingGenerateUuidFromPciBusInfoThenFalseIsReturned) {
initGlobalOps();
std::array<uint8_t, NEO::ProductHelper::uuidSize> uuid;
NEO::PhysicalDevicePciBusInfo pciBusInfo = {};
pciBusInfo.pciDomain = std::numeric_limits<uint32_t>::max();
bool result = pGlobalOperationsImp->pOsGlobalOperations->generateUuidFromPciBusInfo(pciBusInfo, uuid);
EXPECT_EQ(false, result);
}
TEST_F(SysmanGlobalOperationsUuidFixture, GivenNullOsInterfaceObjectWhenRetrievingUuidThenFalseIsReturned) {
initGlobalOps();
auto &rootDeviceEnvironment = (pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironmentRef());
auto prevOsInterface = std::move(rootDeviceEnvironment.osInterface);
rootDeviceEnvironment.osInterface = nullptr;
std::array<uint8_t, NEO::ProductHelper::uuidSize> uuid;
bool result = pGlobalOperationsImp->pOsGlobalOperations->getUuid(uuid);
EXPECT_EQ(false, result);
rootDeviceEnvironment.osInterface = std::move(prevOsInterface);
}
TEST_F(SysmanGlobalOperationsUuidFixture, GivenInvalidPciBusInfoWhenRetrievingUuidThenFalseIsReturned) {
class SysmanMockWddm : public NEO::WddmMock {
public:
SysmanMockWddm(RootDeviceEnvironment &rootDeviceEnvironment) : WddmMock(rootDeviceEnvironment) {}
PhysicalDevicePciBusInfo getPciBusInfo() const override {
PhysicalDevicePciBusInfo pciBusInfo = {};
pciBusInfo.pciDomain = std::numeric_limits<uint32_t>::max();
return pciBusInfo;
}
};
initGlobalOps();
auto &rootDeviceEnvironment = (pWddmSysmanImp->getSysmanDeviceImp()->getRootDeviceEnvironmentRef());
rootDeviceEnvironment.osInterface->setDriverModel(std::unique_ptr<DriverModel>(new SysmanMockWddm(rootDeviceEnvironment)));
std::array<uint8_t, NEO::ProductHelper::uuidSize> uuid;
bool result = pGlobalOperationsImp->pOsGlobalOperations->getUuid(uuid);
EXPECT_EQ(false, result);
}
} // namespace ult
} // namespace Sysman
} // namespace L0