feature: Add pyzes support for VF management, temperature config, engine activity ext and standby APIs

bindings/sysman/python/README.md

@@ -196,10 +196,22 @@ SUPPORTED APIs
 | `zesTemperatureGetProperties` | Temperature | 0.1.0 | None |
 | `zesTemperatureGetConfig` | Temperature | 0.1.0 | None |
 | `zesTemperatureGetState` | Temperature | 0.1.0 | Linux: Requires superuser or read permissions for telem nodes |
+| `zesTemperatureSetConfig` | Temperature | 0.1.4 | Linux: Requires superuser |
 | **Engine Management** |-|-|-|
 | `zesDeviceEnumEngineGroups` | Engine | 0.1.0 | Linux: Shows "no handles found" error when not in superuser mode |
 | `zesEngineGetProperties` | Engine | 0.1.0 | None |
 | `zesEngineGetActivity` | Engine | 0.1.0 | None |
+| `zesEngineGetActivityExt` | Engine | 0.1.4 | None |
+| **Standby Management** |-|-|-|
+| `zesDeviceEnumStandbyDomains` | Standby | 0.1.4 | None |
+| `zesStandbyGetProperties` | Standby | 0.1.4 | None |
+| `zesStandbyGetMode` | Standby | 0.1.4 | None |
+| `zesStandbySetMode` | Standby | 0.1.4 | Linux: Requires superuser |
+| **Virtual Function (VF) Management** |-|-|-|
+| `zesDeviceEnumEnabledVFExp` | VF Management | 0.1.4 | Experimental API |
+| `zesVFManagementGetVFCapabilitiesExp2` | VF Management | 0.1.4 | Experimental API |
+| `zesVFManagementGetVFEngineUtilizationExp2` | VF Management | 0.1.4 | Experimental API. Linux: Requires superuser |
+| `zesVFManagementGetVFMemoryUtilizationExp2` | VF Management | 0.1.4 | Experimental API |
 | **PCI Management** |-|-|-|
 | `zesDevicePciGetProperties` | PCI | 0.1.2 | Linux: Requires superuser or read permissions for telem nodes |
 | `zesDevicePciGetState` | PCI | 0.1.2 | Linux: Requires superuser or read permissions for telem nodes |

bindings/sysman/python/source/pyzes/__init__.py

@@ -152,6 +152,14 @@ class zes_ras_handle_t(c_void_p):
     pass
 
 
+class zes_standby_handle_t(c_void_p):
+    pass
+
+
+class zes_vf_handle_t(c_void_p):
+    pass
+
+
 ##
 
 ze_bool_t = c_uint8
@@ -277,6 +285,9 @@ class zes_ras_handle_t(c_void_p):
 ZES_TEMP_SENSORS_GPU_BOARD = 6
 ZES_TEMP_SENSORS_GPU_BOARD_MIN = 7
 ZES_TEMP_SENSORS_VOLTAGE_REGULATOR = 8
+ZES_TEMP_SENSORS_COMPOSITE = 9
+ZES_TEMP_SENSORS_GPU_BOARD_SINGLE = 10
+ZES_TEMP_SENSORS_VOLTAGE_REGULATOR_SINGLE = 11
 ZES_TEMP_SENSORS_FORCE_UINT32 = 0x7FFFFFFF
 
 ## Engine type enums ##
@@ -319,6 +330,15 @@ class zes_ras_handle_t(c_void_p):
 ZES_RAS_ERROR_CATEGORY_EXP_SOC_INTERNAL_ERRORS = 12
 ZES_RAS_ERROR_CATEGORY_EXP_FORCE_UINT32 = 0x7FFFFFFF
 
+zes_standby_type_t = c_int32
+ZES_STANDBY_TYPE_GLOBAL = 0
+ZES_STANDBY_TYPE_FORCE_UINT32 = 0x7FFFFFFF
+
+zes_standby_promo_mode_t = c_int32
+ZES_STANDBY_PROMO_MODE_DEFAULT = 0
+ZES_STANDBY_PROMO_MODE_NEVER = 1
+ZES_STANDBY_PROMO_MODE_FORCE_UINT32 = 0x7FFFFFFF
+
 ze_result_t = c_int32
 ZE_RESULT_SUCCESS = 0
 ZE_RESULT_NOT_READY = 1
@@ -404,6 +424,10 @@ class zes_ras_handle_t(c_void_p):
 ZES_STRUCTURE_TYPE_RAS_PROPERTIES = 0xF
 ZES_STRUCTURE_TYPE_RAS_STATE_EXP2 = 0x00020015
 ZES_STRUCTURE_TYPE_RAS_CONFIG_EXP = 0x00020016
+ZES_STRUCTURE_TYPE_STANDBY_PROPERTIES = 0x13
+ZES_STRUCTURE_TYPE_VF_UTIL_MEM_EXP2 = 0x00020009
+ZES_STRUCTURE_TYPE_VF_UTIL_ENGINE_EXP2 = 0x00020010
+ZES_STRUCTURE_TYPE_VF_EXP2_CAPABILITIES = 0x00020011
 
 
 ## Core ze_device UUID struct ##
@@ -845,6 +869,48 @@ class zes_ras_config_exp_t(_PrintableStructure):
     _fmt_ = {"threshold": "%d"}
 
 
+class zes_standby_properties_t(_PrintableStructure):
+    _fields_ = [
+        ("stype", c_int32),
+        ("pNext", c_void_p),
+        ("type", zes_standby_type_t),
+        ("onSubdevice", ze_bool_t),
+        ("subdeviceId", c_uint32),
+    ]
+
+
+class zes_vf_exp2_capabilities_t(_PrintableStructure):
+    _fields_ = [
+        ("stype", c_int32),
+        ("pNext", c_void_p),
+        ("address", zes_pci_address_t),
+        ("vfDeviceMemSize", c_uint64),
+        ("vfID", c_uint32),
+    ]
+    _fmt_ = {"vfDeviceMemSize": "%d bytes"}
+
+
+class zes_vf_util_mem_exp2_t(_PrintableStructure):
+    _fields_ = [
+        ("stype", c_int32),
+        ("pNext", c_void_p),
+        ("vfMemLocation", zes_mem_loc_t),
+        ("vfMemUtilized", c_uint64),
+    ]
+    _fmt_ = {"vfMemUtilized": "%d bytes"}
+
+
+class zes_vf_util_engine_exp2_t(_PrintableStructure):
+    _fields_ = [
+        ("stype", c_int32),
+        ("pNext", c_void_p),
+        ("vfEngineType", zes_engine_group_t),
+        ("activeCounterValue", c_uint64),
+        ("samplingCounterValue", c_uint64),
+    ]
+    _fmt_ = {"activeCounterValue": "%d", "samplingCounterValue": "%d"}
+
+
 ## Function access ##
 _getFunctionPointerList: Dict[str, Any] = dict()
 
@@ -1660,6 +1726,26 @@ def zesTemperatureGetState(hTemperature, pTemperature):
     return retVal
 
 
+def zesTemperatureSetConfig(hTemperature, pConfig):
+    """Wraps API:
+    ze_result_t zesTemperatureSetConfig(
+        zes_temp_handle_t hTemperature,
+        const zes_temp_config_t* pConfig)
+
+    Parameters:
+      hTemperature: temperature handle
+      pConfig: POINTER(zes_temp_config_t) - new configuration
+    Returns:
+      ze_result_t - return code only
+    """
+    funcPtr = getFunctionPointerList("zesTemperatureSetConfig")
+    funcPtr.argtypes = [zes_temp_handle_t, POINTER(zes_temp_config_t)]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hTemperature, pConfig)
+    return retVal
+
+
 ## Engine functions ##
 
 
@@ -1886,3 +1972,207 @@ def zesRasClearStateExp(hRas, category):
 
     retVal = funcPtr(hRas, category)
     return retVal
+
+
+def zesEngineGetActivityExt(hEngine, pCount, pStats):
+    """Wraps API:
+    ze_result_t zesEngineGetActivityExt(
+        zes_engine_handle_t hEngine,
+        uint32_t* pCount,
+        zes_engine_stats_t* pStats)
+
+    Parameters:
+      hEngine: engine handle
+      pCount: POINTER(c_uint32)
+      pStats: POINTER(zes_engine_stats_t) or None - PF stats at index 0 followed by VF stats
+    Returns:
+      ze_result_t - return code only, stats are filled into pStats
+    """
+    funcPtr = getFunctionPointerList("zesEngineGetActivityExt")
+    funcPtr.argtypes = [
+        zes_engine_handle_t,
+        POINTER(c_uint32),
+        POINTER(zes_engine_stats_t),
+    ]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hEngine, pCount, pStats)
+    return retVal
+
+
+def zesDeviceEnumStandbyDomains(hDevice, pCount, phStandby):
+    """Wraps API:
+    ze_result_t zesDeviceEnumStandbyDomains(
+        zes_device_handle_t hDevice,
+        uint32_t* pCount,
+        zes_standby_handle_t* phStandby)
+
+    Parameters:
+      hDevice: device handle
+      pCount: POINTER(c_uint32)
+      phStandby: POINTER(zes_standby_handle_t) or None
+    """
+    funcPtr = getFunctionPointerList("zesDeviceEnumStandbyDomains")
+    funcPtr.argtypes = [
+        zes_device_handle_t,
+        POINTER(c_uint32),
+        POINTER(zes_standby_handle_t),
+    ]
+    funcPtr.restype = ze_result_t
+    retVal = funcPtr(hDevice, pCount, phStandby)
+    return retVal
+
+
+def zesStandbyGetProperties(hStandby, pProperties):
+    """Wraps API:
+    ze_result_t zesStandbyGetProperties(
+        zes_standby_handle_t hStandby,
+        zes_standby_properties_t* pProperties)
+
+    Parameters:
+      hStandby: standby handle
+      pProperties: POINTER(zes_standby_properties_t) - properties structure to fill
+    Returns:
+      ze_result_t - return code only, properties are filled into pProperties
+    """
+    funcPtr = getFunctionPointerList("zesStandbyGetProperties")
+    funcPtr.argtypes = [zes_standby_handle_t, POINTER(zes_standby_properties_t)]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hStandby, pProperties)
+    return retVal
+
+
+def zesStandbyGetMode(hStandby, pMode):
+    """Wraps API:
+    ze_result_t zesStandbyGetMode(
+        zes_standby_handle_t hStandby,
+        zes_standby_promo_mode_t* pMode)
+
+    Parameters:
+      hStandby: standby handle
+      pMode: POINTER(zes_standby_promo_mode_t) - current standby mode to fill
+    Returns:
+      ze_result_t - return code only, mode is filled into pMode
+    """
+    funcPtr = getFunctionPointerList("zesStandbyGetMode")
+    funcPtr.argtypes = [zes_standby_handle_t, POINTER(zes_standby_promo_mode_t)]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hStandby, pMode)
+    return retVal
+
+
+def zesStandbySetMode(hStandby, mode):
+    """Wraps API:
+    ze_result_t zesStandbySetMode(
+        zes_standby_handle_t hStandby,
+        zes_standby_promo_mode_t mode)
+
+    Parameters:
+      hStandby: standby handle
+      mode: zes_standby_promo_mode_t - new standby mode
+    Returns:
+      ze_result_t - return code only
+    """
+    funcPtr = getFunctionPointerList("zesStandbySetMode")
+    funcPtr.argtypes = [zes_standby_handle_t, zes_standby_promo_mode_t]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hStandby, mode)
+    return retVal
+
+
+def zesDeviceEnumEnabledVFExp(hDevice, pCount, phVFhandle):
+    """Wraps API:
+    ze_result_t zesDeviceEnumEnabledVFExp(
+        zes_device_handle_t hDevice,
+        uint32_t* pCount,
+        zes_vf_handle_t* phVFhandle)
+
+    Parameters:
+      hDevice: device handle
+      pCount: POINTER(c_uint32)
+      phVFhandle: POINTER(zes_vf_handle_t) or None
+    """
+    funcPtr = getFunctionPointerList("zesDeviceEnumEnabledVFExp")
+    funcPtr.argtypes = [
+        zes_device_handle_t,
+        POINTER(c_uint32),
+        POINTER(zes_vf_handle_t),
+    ]
+    funcPtr.restype = ze_result_t
+    retVal = funcPtr(hDevice, pCount, phVFhandle)
+    return retVal
+
+
+def zesVFManagementGetVFCapabilitiesExp2(hVFhandle, pCapability):
+    """Wraps API:
+    ze_result_t zesVFManagementGetVFCapabilitiesExp2(
+        zes_vf_handle_t hVFhandle,
+        zes_vf_exp2_capabilities_t* pCapability)
+
+    Parameters:
+      hVFhandle: VF handle
+      pCapability: POINTER(zes_vf_exp2_capabilities_t) - capability structure to fill
+    Returns:
+      ze_result_t - return code only, capability is filled into pCapability
+    """
+    funcPtr = getFunctionPointerList("zesVFManagementGetVFCapabilitiesExp2")
+    funcPtr.argtypes = [zes_vf_handle_t, POINTER(zes_vf_exp2_capabilities_t)]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hVFhandle, pCapability)
+    return retVal
+
+
+def zesVFManagementGetVFEngineUtilizationExp2(hVFhandle, pCount, pEngineUtil):
+    """Wraps API:
+    ze_result_t zesVFManagementGetVFEngineUtilizationExp2(
+        zes_vf_handle_t hVFhandle,
+        uint32_t* pCount,
+        zes_vf_util_engine_exp2_t* pEngineUtil)
+
+    Parameters:
+      hVFhandle: VF handle
+      pCount: POINTER(c_uint32)
+      pEngineUtil: POINTER(zes_vf_util_engine_exp2_t) or None
+    Returns:
+      ze_result_t - return code only, engine utilization is filled into pEngineUtil
+    """
+    funcPtr = getFunctionPointerList("zesVFManagementGetVFEngineUtilizationExp2")
+    funcPtr.argtypes = [
+        zes_vf_handle_t,
+        POINTER(c_uint32),
+        POINTER(zes_vf_util_engine_exp2_t),
+    ]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hVFhandle, pCount, pEngineUtil)
+    return retVal
+
+
+def zesVFManagementGetVFMemoryUtilizationExp2(hVFhandle, pCount, pMemUtil):
+    """Wraps API:
+    ze_result_t zesVFManagementGetVFMemoryUtilizationExp2(
+        zes_vf_handle_t hVFhandle,
+        uint32_t* pCount,
+        zes_vf_util_mem_exp2_t* pMemUtil)
+
+    Parameters:
+      hVFhandle: VF handle
+      pCount: POINTER(c_uint32)
+      pMemUtil: POINTER(zes_vf_util_mem_exp2_t) or None
+    Returns:
+      ze_result_t - return code only, memory utilization is filled into pMemUtil
+    """
+    funcPtr = getFunctionPointerList("zesVFManagementGetVFMemoryUtilizationExp2")
+    funcPtr.argtypes = [
+        zes_vf_handle_t,
+        POINTER(c_uint32),
+        POINTER(zes_vf_util_mem_exp2_t),
+    ]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hVFhandle, pCount, pMemUtil)
+    return retVal