intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-19 16:24:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature(sysman): implement getExtensionProperties in sysman driver component

Browse Source 
Related-To: NEO-16529

Signed-off-by: Sarbojit Sarkar <sarbojit.sarkar@intel.com>
This commit is contained in:
Sarbojit Sarkar
2025-10-31 07:38:12 +00:00
committed by Compute-Runtime-Automation
parent 5abdcc045e
commit 44edb8dfdd
7 changed files with 211 additions and 6 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
level_zero/include/level_zero/zes_intel_gpu_sysman.h
View File

@@ -21,6 +21,12 @@ extern "C" {
#define ZES_INTEL_GPU_SYSMAN_VERSION_MAJOR 0
#define ZES_INTEL_GPU_SYSMAN_VERSION_MINOR 1
///////////////////////////////////////////////////////////////////////////////
#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
/// @brief PCI link speed downgrade state extension name
#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME "ZES_intel_experimental_pci_link_speed_downgrade_state"
#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME
///////////////////////////////////////////////////////////////////////////////
/// @brief Query pcie downgrade status extension Version(s)
typedef enum _zes_intel_pci_link_speed_downgrade_exp_state_version_t {
@@ -39,6 +45,12 @@ typedef struct _zes_intel_pci_link_speed_downgrade_exp_state_t {
ze_bool_t pciLinkSpeedDowngradeStatus; ///< [out] Returns the current PCIe downgrade status .
} zes_intel_pci_link_speed_downgrade_exp_state_t;
///////////////////////////////////////////////////////////////////////////////
#ifndef ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
/// @brief PCI link speed downgrade property extension name
#define ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME "ZES_intel_experimental_pci_link_speed_downgrade_property"
#endif // ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME
///////////////////////////////////////////////////////////////////////////////
/// @brief Query pcie downgrade capability extension Version(s)
typedef enum _zes_intel_pci_link_speed_downgrade_exp_properties_version_t {
@@ -64,6 +76,12 @@ ze_result_t ZE_APICALL zesIntelDevicePciLinkSpeedUpdateExp(
zes_device_action_t *pendingAction ///< [out] Pending action
);
///////////////////////////////////////////////////////////////////////////////
#ifndef ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
/// @brief Driver name property extension name
#define ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME "ZES_intel_experimental_driver_name_property"
#endif // ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME
///////////////////////////////////////////////////////////////////////////////
/// @brief Query driver name extension Version(s)
typedef enum _zes_intel_driver_name_exp_properties_version_t {

3
level_zero/sysman/source/driver/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
#
# Copyright (C) 2023 Intel Corporation
# Copyright (C) 2023-2025 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
@@ -12,6 +12,7 @@ target_sources(${L0_STATIC_LIB_NAME}
${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle.h
${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp.h
${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp_helper.cpp
${CMAKE_CURRENT_SOURCE_DIR}/sysman_driver_handle_imp.cpp
${CMAKE_CURRENT_SOURCE_DIR}/os_sysman_driver.h
)

12
level_zero/sysman/source/driver/sysman_driver_handle_imp.cpp
View File

@@ -240,7 +240,17 @@ ze_result_t SysmanDriverHandleImp::getDeviceByUuid(zes_uuid_t uuid, zes_device_h
}
ze_result_t SysmanDriverHandleImp::getExtensionProperties(uint32_t *pCount, zes_driver_extension_properties_t *pExtensionProperties) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
if (*pCount == 0) {
*pCount = static_cast<uint32_t>(extensionsSupported.size());
return ZE_RESULT_SUCCESS;
}
uint32_t numExtensionsToCopy = std::min(*pCount, static_cast<uint32_t>(extensionsSupported.size()));
for (uint32_t i = 0; i < numExtensionsToCopy; i++) {
std::strncpy(pExtensionProperties[i].name, extensionsSupported[i].first.c_str(), ZE_MAX_EXTENSION_NAME);
pExtensionProperties[i].version = extensionsSupported[i].second;
}
*pCount = numExtensionsToCopy;
return ZE_RESULT_SUCCESS;
}
ze_result_t SysmanDriverHandleImp::sysmanEventsListen(uint32_t timeout, uint32_t count, zes_device_handle_t *phDevices, uint32_t *pNumDeviceEvents, zes_event_type_flags_t *pEvents) {

3
level_zero/sysman/source/driver/sysman_driver_handle_imp.h
View File

@@ -11,6 +11,7 @@
#include <mutex>
#include <string>
#include <unordered_map>
#include <vector>
namespace NEO {
class ExecutionEnvironment;
@@ -40,6 +41,8 @@ struct SysmanDriverHandleImp : SysmanDriverHandle {
const std::unordered_map<std::string, SysmanDevice *> &getUuidDeviceMap() const {
return uuidDeviceMap;
}
// list of supported extension apis
static const std::vector<std::pair<std::string, uint32_t>> extensionsSupported;
private:
void updateUuidMap(SysmanDevice *sysmanDevice);

31
level_zero/sysman/source/driver/sysman_driver_handle_imp_helper.cpp Normal file
View File

@@ -0,0 +1,31 @@
/*
* Copyright (C) 2025 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h"
#include "level_zero/zes_api.h"
#include "level_zero/zes_intel_gpu_sysman.h"
namespace L0 {
namespace Sysman {
const std::vector<std::pair<std::string, uint32_t>> SysmanDriverHandleImp::extensionsSupported = {
// zes_api extensions
{ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
{ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
{ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
{ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
{ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
{ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
{ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
{ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
// zes_intel_gpu_sysman extensions
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
{ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
} // namespace Sysman
} // namespace L0

84
level_zero/sysman/test/unit_tests/sources/linux/test_sysman_driver.cpp
View File

@@ -15,6 +15,7 @@
#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_driver.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_drm.h"
#include "level_zero/zes_intel_gpu_sysman.h"
#include "gtest/gtest.h"
@@ -227,8 +228,32 @@ TEST_F(SysmanDriverHandleTest, whenQueryingForDevicesWithCountGreaterThanZeroAnd
EXPECT_EQ(ZE_RESULT_ERROR_INVALID_NULL_HANDLE, result);
}
bool verifyExtensionDefinition(std::vector<zes_driver_extension_properties_t> &extensionsReturned, uint32_t count) {
const std::vector<std::pair<std::string, uint32_t>> supportedExtensions = {
{ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
{ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
{ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
{ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
{ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
{ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
{ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
{ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
{ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
for (uint32_t i = 0; i < count; i++) {
if (extensionsReturned[i].name != supportedExtensions[i].first) {
return false;
}
if (extensionsReturned[i].version != supportedExtensions[i].second) {
return false;
}
}
return true;
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenUnsupportedIsReturned) {
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenAllSupportedExtensionsAreReturned) {
uint32_t count = 0;
ze_result_t result = zesDriverGet(&count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
@@ -239,7 +264,62 @@ TEST_F(SysmanDriverHandleTest,
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, driverHandle);
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
EXPECT_GE(pCount, 0u);
std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithInvalidCountThenValidSupportedExtensionsCountIsReturned) {
uint32_t count = 0;
ze_result_t result = zesDriverGet(&count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1U, count);
ze_driver_handle_t driverHandle = {};
result = zesDriverGet(&count, &driverHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, driverHandle);
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
EXPECT_GE(pCount, 0u);
std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
auto actualCount = pCount; // Store the actual count
pCount += 5; // Intentionally increase the count to check if function adjusts it correctly
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
EXPECT_EQ(actualCount, pCount);
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithCountLessThanActualSizeThenSameNumberOfSupportedExtensionsReturned) {
uint32_t count = 0;
ze_result_t result = zesDriverGet(&count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(1U, count);
ze_driver_handle_t driverHandle = {};
result = zesDriverGet(&count, &driverHandle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_NE(nullptr, driverHandle);
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, nullptr));
EXPECT_GE(pCount, 0u);
auto actualCount = pCount; // Store the actual count
std::vector<zes_driver_extension_properties_t> extensionsSupported(actualCount);
pCount -= 1; // Intentionally decrease the count to check if function adjusts it correctly
// Filled with invalid data to ensure only valid extensions are filled by driver function
strcpy_s(extensionsSupported[pCount].name, ZES_MAX_EXTENSION_NAME, "Invalid_Extension_Name");
extensionsSupported[pCount].version = 1234;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle, &pCount, extensionsSupported.data()));
EXPECT_EQ(actualCount - 1, pCount);
EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
// Verify that the last entry remains unchanged
EXPECT_EQ(strcmp(extensionsSupported[actualCount - 1].name, "Invalid_Extension_Name"), 0);
EXPECT_EQ(extensionsSupported[actualCount - 1].version, static_cast<uint32_t>(1234));
}
TEST_F(SysmanDriverHandleTest,

66
level_zero/sysman/test/unit_tests/sources/windows/test_sysman_driver.cpp
View File

@@ -6,6 +6,7 @@
*/
#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_driver.h"
#include "level_zero/zes_intel_gpu_sysman.h"
#include "gtest/gtest.h"
@@ -51,10 +52,71 @@ TEST(zesInit, whenCallingZesInitWhenDriverInitFailsThenUninitializedIsReturned)
EXPECT_EQ(1u, driver.initCalledCount);
}
bool verifyExtensionDefinition(std::vector<zes_driver_extension_properties_t> &extensionsReturned, uint32_t count) {
const std::vector<std::pair<std::string, uint32_t>> supportedExtensions = {
{ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_NAME, ZES_DEVICE_ECC_DEFAULT_PROPERTIES_EXT_VERSION_CURRENT},
{ZES_POWER_LIMITS_EXT_NAME, ZES_POWER_LIMITS_EXT_VERSION_CURRENT},
{ZES_ENGINE_ACTIVITY_EXT_NAME, ZES_ENGINE_ACTIVITY_EXT_VERSION_CURRENT},
{ZES_RAS_GET_STATE_EXP_NAME, ZES_RAS_STATE_EXP_VERSION_CURRENT},
{ZES_MEM_PAGE_OFFLINE_STATE_EXP_NAME, ZES_MEM_PAGE_OFFLINE_STATE_EXP_VERSION_CURRENT},
{ZES_MEMORY_BANDWIDTH_COUNTER_BITS_EXP_PROPERTIES_NAME, ZES_MEM_BANDWIDTH_COUNTER_BITS_EXP_VERSION_CURRENT},
{ZES_SYSMAN_DEVICE_MAPPING_EXP_NAME, ZES_SYSMAN_DEVICE_MAPPING_EXP_VERSION_CURRENT},
{ZES_VIRTUAL_FUNCTION_MANAGEMENT_EXP_NAME, ZES_VF_MANAGEMENT_EXP_VERSION_CURRENT},
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_STATE_VERSION_CURRENT},
{ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTY_NAME, ZES_INTEL_PCI_LINK_SPEED_DOWNGRADE_EXP_PROPERTIES_VERSION_CURRENT},
{ZES_INTEL_DRIVER_NAME_EXP_PROPERTY_NAME, ZES_INTEL_DRIVER_NAME_EXP_PROPERTIES_VERSION_CURRENT}};
for (uint32_t i = 0; i < count; i++) {
if (extensionsReturned[i].name != supportedExtensions[i].first) {
return false;
}
if (extensionsReturned[i].version != supportedExtensions[i].second) {
return false;
}
}
return true;
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenZesDriverGetPropertiesIsCalledThenUnsupportedIsReturned) {
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledThenAllSupportedExtensionsAreReturned) {
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
EXPECT_GE(pCount, 0u);
std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithInvalidCountThenValidSupportedExtensionsCountIsReturned) {
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
EXPECT_GE(pCount, 0u);
std::vector<zes_driver_extension_properties_t> extensionsSupported(pCount);
auto actualCount = pCount; // Store the actual count
pCount += 5; // Intentionally increase the count to check if function adjusts it correctly
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
EXPECT_EQ(actualCount, pCount);
}
TEST_F(SysmanDriverHandleTest,
givenInitializedDriverWhenzesDriverGetExtensionPropertiesIsCalledWithCountLessThanActualSizeThenSameNumberOfSupportedExtensionsReturned) {
uint32_t pCount = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, nullptr));
EXPECT_GE(pCount, 0u);
auto actualCount = pCount; // Store the actual count
std::vector<zes_driver_extension_properties_t> extensionsSupported(actualCount);
pCount -= 1; // Intentionally decrease the count to check if function adjusts it correctly
// Filled with invalid data to ensure only valid extensions are filled by driver function
strcpy_s(extensionsSupported[pCount].name, ZES_MAX_EXTENSION_NAME, "Invalid_Extension_Name");
extensionsSupported[pCount].version = 1234;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGetExtensionProperties(driverHandle->toHandle(), &pCount, extensionsSupported.data()));
EXPECT_EQ(actualCount - 1, pCount);
EXPECT_TRUE(verifyExtensionDefinition(extensionsSupported, pCount));
// Verify that the last entry remains unchanged
EXPECT_EQ(strcmp(extensionsSupported[actualCount - 1].name, "Invalid_Extension_Name"), 0);
EXPECT_EQ(extensionsSupported[actualCount - 1].version, static_cast<uint32_t>(1234));
}
TEST_F(SysmanDriverHandleTest,