mbltml.py Source File

mbltml.py Source File#

mbltml: mbltml.py Source File
mbltml Test Preview
mbltml — EN
 
import os
import glob
import platform
from ctypes import *
from pathlib import Path
from typing import List, Set
 
 
MBLTML_DRIVER_VERSION_BUFFER_SIZE = 80
MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE = 80
MBLTML_FIRMWARE_VERSION_BUFFER_SIZE = 80
MBLTML_NODE_NAME_BUFFER_SIZE = 80
 
mbltmlDeviceType_t = c_uint
MBLTML_DEVICE_ERROR = 0x0  
MBLTML_DEVICE_ARIES = 0x1  
MBLTML_DEVICE_REGULUS = 0x2  
MBLTML_DEVICE_REGULUS_USB = 0x4  
 
mbltmlHardwareVersion_t = c_uint
MBLTML_HARDWARE_VERSION_ARIES_RA = 0x00000001  
MBLTML_HARDWARE_VERSION_REGULUS_RA = 0x00000002  
MBLTML_HARDWARE_VERSION_ARIES_RB = 0x00000003  
MBLTML_HARDWARE_VERSION_REGULUS_RB = 0x00000004  
MBLTML_HARDWARE_VERSION_ERROR = 0x7FFFFFFF  
 
mbltmlStatusCode_t = c_uint
MBLTML_SUCCESS = 0  
MBLTML_DRIVER_NOT_FOUND = 2  
MBLTML_INVALID_ARGUMENT = 3  
MBLTML_UNINITIALIZED = 1  
MBLTML_NOT_SUPPORTED = 4  
MBLTML_INSUFFICIENT_LENGTH = 5  
 
mbltmlExtraPmicId_t = c_uint
MBLTML_EXTRA_PMIC_ID_NPU = 0  
MBLTML_EXTRA_PMIC_ID_DDR = 1  
MBLTML_EXTRA_PMIC_ID_PMIC = 2  
MBLTML_EXTRA_PMIC_ID_GOLDFINGER = 3  
 
mbltmlCluster_t = c_uint
MBLTML_CLUSTER_0 = 0x00010000  
MBLTML_CLUSTER_1 = 0x00020000  
MBLTML_CLUSTER_ERROR = 0x7FFF0000  
 
mbltmlCore_t = c_uint
MBLTML_CORE_0 = 1  
MBLTML_CORE_1 = 2  
MBLTML_CORE_2 = 3  
MBLTML_CORE_3 = 4  
MBLTML_CORE_GLOBAL = 0x0000FFFE  
MBLTML_CORE_ERROR = 0x0000FFFF  
 
 
# Classes
class mbltmlCoreId_t(Structure):
    """@brief Composite identifier of an NPU core (cluster + core).
 
    @var cluster Cluster to which the core belongs (mbltmlCluster_t).
    @var core    Core within the cluster (mbltmlCore_t).
    """
 
    cluster: mbltmlCluster_t
    core: mbltmlCore_t
    _fields_ = [
        ("cluster", mbltmlCluster_t),
        ("core", mbltmlCore_t),
    ]
 
    def __repr__(self):
        d = {"cluster": self.cluster, "core": self.core}
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
class mbltmlCoreInfo_t(Structure):
    """@brief Per-core usage record returned by mbltmlGetCoreInfos().
 
    Utilization for the core can be computed as @c npu_time / @c interval
    when @c interval is non-zero.
 
    @var core_id  Identifier of the core (mbltmlCoreId_t).
    @var npu_time Accumulated NPU active time on the core, in microseconds.
    @var interval Sampling interval covered by @c npu_time, in microseconds.
    """
 
    core_id: mbltmlCoreId_t
    npu_time: c_int64
    interval: c_int64
    _fields_ = [
        ("core_id", mbltmlCoreId_t),
        ("npu_time", c_int64),
        ("interval", c_int64),
    ]
 
    def __repr__(self):
        d = {
            "core_id": self.core_id,
            "npu_time": self.npu_time,
            "interval": self.interval,
        }
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
class mbltmlProcessInfo_t(Structure):
    """@brief Per-process usage record returned by mbltmlGetProcessInfos().
 
    Utilization for the process can be computed as
    @c total_npu_time_us / @c total_interval_us when @c total_interval_us
    is non-zero.
 
    @var pid               Process ID.
    @var counts            Number of NPU samples attributed to the process.
    @var npu_memory_usage  Device memory currently used by the process, in bytes.
    @var total_interval_us Total sampling interval, in microseconds.
    @var total_npu_time_us Total NPU active time used by the process, in microseconds.
    """
 
    pid: c_int
    counts: c_int
    npu_memory_usage: c_int64
    total_interval_us: c_int64
    total_npu_time_us: c_int64
    _fields_ = [
        ("pid", c_int),
        ("counts", c_int),
        ("npu_memory_usage", c_int64),
        ("total_interval_us", c_int64),
        ("total_npu_time_us", c_int64),
    ]
 
    def __repr__(self):
        d = {
            "pid": self.pid,
            "counts": self.counts,
            "npu_memory_usage": self.npu_memory_usage,
            "total_interval_us": self.total_interval_us,
            "total_npu_time_us": self.total_npu_time_us,
        }
        return "{}({})".format(
            self.__class__.__name__,
            ", ".join("{}={}".format(k, v) for k, v in d.items()),
        )
 
 
_clib = None
 
 
def _loadLibrary() -> None:
    global _clib
    if _clib != None:
        return
    lib_fname = "mbltml.dll" if platform.system() == "Windows" else f"libmbltml.so*"
    pattern = os.path.join(Path(__file__).resolve().parent, lib_fname)
    candidates = glob.glob(pattern)
    if not candidates:
        raise FileNotFoundError(f"No library matching {pattern}")
    candidates.sort(key=len, reverse=True)
    _clib = CDLL(str(candidates[0]))
 
    _clib.mbltmlInit.argtypes = []
    _clib.mbltmlInit.restype = mbltmlStatusCode_t
    _clib.mbltmlInitDevices.argtypes = [mbltmlDeviceType_t]
    _clib.mbltmlInitDevices.restype = mbltmlStatusCode_t
    _clib.mbltmlShutdown.argtypes = []
    _clib.mbltmlShutdown.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDeviceCount.argtypes = [POINTER(c_uint)]
    _clib.mbltmlGetDeviceCount.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDriverVersion.argtypes = [mbltmlDeviceType_t, POINTER(c_char), c_int]
    _clib.mbltmlGetDriverVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDriverRevision.argtypes = [mbltmlDeviceType_t, POINTER(c_uint)]
    _clib.mbltmlGetDriverRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetNodeName.argtypes = [c_int, POINTER(c_char), c_int]
    _clib.mbltmlGetNodeName.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDeviceType.argtypes = [c_int, POINTER(mbltmlDeviceType_t)]
    _clib.mbltmlGetDeviceType.restype = mbltmlStatusCode_t
    _clib.mbltmlGetHardwareVersion.argtypes = [c_int, POINTER(mbltmlHardwareVersion_t)]
    _clib.mbltmlGetHardwareVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetOnDeviceDriverVersion.argtypes = [c_int, POINTER(c_char), c_uint]
    _clib.mbltmlGetOnDeviceDriverVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetOnDeviceDriverRevision.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetOnDeviceDriverRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareVersion.argtypes = [c_int, POINTER(c_char), c_uint]
    _clib.mbltmlGetFirmwareVersion.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareRevision.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetFirmwareRevision.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFirmwareCRC.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetFirmwareCRC.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTemperature.argtypes = [c_int, POINTER(c_int)]
    _clib.mbltmlGetTemperature.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSignalType.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetSignalType.restype = mbltmlStatusCode_t
    _clib.mbltmlGetNPUClock.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetNPUClock.restype = mbltmlStatusCode_t
    _clib.mbltmlGetBusClock.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetBusClock.restype = mbltmlStatusCode_t
    _clib.mbltmlGetFanDuty.argtypes = [c_int, POINTER(c_int)]
    _clib.mbltmlGetFanDuty.restype = mbltmlStatusCode_t
    _clib.mbltmlGetVendorId.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetVendorId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetDeviceId.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetDeviceId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSubVendorId.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetSubVendorId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetSubDeviceId.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetSubDeviceId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieGen.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieGen.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieLanes.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieLanes.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieRev.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieRev.restype = mbltmlStatusCode_t
    _clib.mbltmlGetPcieClassCode.argtypes = [c_int, POINTER(c_uint)]
    _clib.mbltmlGetPcieClassCode.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalPower.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetTotalPower.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalCurrent.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetTotalCurrent.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalVoltage.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetTotalVoltage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicPower.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetExtraPmicPower.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicCurrent.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetExtraPmicCurrent.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicVoltage.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetExtraPmicVoltage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetExtraPmicId.argtypes = [c_int, POINTER(mbltmlExtraPmicId_t)]
    _clib.mbltmlGetExtraPmicId.restype = mbltmlStatusCode_t
    _clib.mbltmlGetTotalUtilization.argtypes = [c_int, POINTER(c_double)]
    _clib.mbltmlGetTotalUtilization.restype = mbltmlStatusCode_t
    _clib.mbltmlGetMemoryUsage.argtypes = [c_int, POINTER(c_int64)]
    _clib.mbltmlGetMemoryUsage.restype = mbltmlStatusCode_t
    _clib.mbltmlGetMemoryTotal.argtypes = [c_int, POINTER(c_int64)]
    _clib.mbltmlGetMemoryTotal.restype = mbltmlStatusCode_t
    _clib.mbltmlGetProcessInfos.argtypes = [
        c_int,
        POINTER(mbltmlProcessInfo_t),
        POINTER(c_uint),
    ]
    _clib.mbltmlGetProcessInfos.restype = mbltmlStatusCode_t
    _clib.mbltmlGetCoreInfos.argtypes = [
        c_int,
        POINTER(mbltmlCoreInfo_t),
        POINTER(c_uint),
    ]
    _clib.mbltmlGetCoreInfos.restype = mbltmlStatusCode_t
    _clib.mbltmlSetExtraPmicID.argtypes = [c_int, mbltmlExtraPmicId_t]
    _clib.mbltmlSetExtraPmicID.restype = mbltmlStatusCode_t
 
 
class MBLTMLError(Exception):
    """@brief Base exception raised by the mbltml Python binding.
 
    Wraps a non-success mbltmlStatusCode_t returned by the underlying C
    library. Instantiating MBLTMLError with a known status code yields the
    matching subclass (e.g., MBLTMLInvalidArgumentError).
 
    @var code The mbltmlStatusCode_t value associated with this exception.
    """
 
    _code_to_class = {}
    _errcode_to_string = {
        MBLTML_DRIVER_NOT_FOUND: "Driver is not found",
        MBLTML_INVALID_ARGUMENT: "Invalid Argument",
        MBLTML_UNINITIALIZED: "Uninitilized mbltml.",
        MBLTML_NOT_SUPPORTED: "Unspported Function for Target Device",
        MBLTML_INSUFFICIENT_LENGTH: "Insufficient Length",
    }
 
    def __new__(cls, code: mbltmlStatusCode_t):
        if cls is MBLTMLError and code in MBLTMLError._code_to_class:
            cls = MBLTMLError._code_to_class[code]
        obj = Exception.__new__(cls)
        obj.code = code
        return obj
 
    def __str__(self):
        return MBLTMLError._errcode_to_string[self.code]
 
    def __eq__(self, other):
        return self.code == other.code
 
 
class MBLTMLDriverNotFoundError(MBLTMLError):
    """@brief Raised when the required driver cannot be located.
 
    Wraps MBLTML_DRIVER_NOT_FOUND.
    """
 
    pass
 
 
class MBLTMLInvalidArgumentError(MBLTMLError):
    """@brief Raised when one or more arguments are invalid.
 
    Wraps MBLTML_INVALID_ARGUMENT. Typical causes include a NULL pointer or
    a @c dev_no that is out of range of the device count.
    """
 
    pass
 
 
class MBLTMLUninitializedError(MBLTMLError):
    """@brief Raised when an API is called before initialization.
 
    Wraps MBLTML_UNINITIALIZED. Call mbltmlInit() or mbltmlInitDevices() first.
    """
 
    pass
 
 
class MBLTMLNotSupportedError(MBLTMLError):
    """@brief Raised when the feature is not supported on the target device.
 
    Wraps MBLTML_NOT_SUPPORTED.
    """
 
    pass
 
 
class MBLTMLInsufficientLengthError(MBLTMLError):
    """@brief Raised when the output buffer is too small to hold the result.
 
    Wraps MBLTML_INSUFFICIENT_LENGTH.
    """
 
    pass
 
 
MBLTMLError._code_to_class = {
    MBLTML_DRIVER_NOT_FOUND: MBLTMLDriverNotFoundError,
    MBLTML_INVALID_ARGUMENT: MBLTMLInvalidArgumentError,
    MBLTML_UNINITIALIZED: MBLTMLUninitializedError,
    MBLTML_NOT_SUPPORTED: MBLTMLNotSupportedError,
    MBLTML_INSUFFICIENT_LENGTH: MBLTMLInsufficientLengthError,
}
 
 
def _mbltmlThrowError(ret: mbltmlStatusCode_t) -> None:
    if ret != MBLTML_SUCCESS:
        raise MBLTMLError(ret)
 
 
# Function calls
def mbltmlInit() -> None:
    """@brief Initialize the mbltml library for all supported device types.
 
    Equivalent to calling mbltmlInitDevices() with every mbltmlDeviceType_t
    enabled. Must be called (directly or via mbltmlInitDevices()) before any
    other mbltml API.
 
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    ret = _clib.mbltmlInit()
    _mbltmlThrowError(ret)
 
 
def mbltmlInitDevices(device_types: Set[mbltmlDeviceType_t]) -> None:
    """@brief Initialize the mbltml library for a selected set of device types.
 
    @param device_types Set of mbltmlDeviceType_t values indicating which
                        device families to enumerate and monitor.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    all_device_types = 0
    for dt in device_types:
        all_device_types = all_device_types | dt
    ret = _clib.mbltmlInitDevices(all_device_types)
    _mbltmlThrowError(ret)
 
 
def mbltmlShutdown() -> None:
    """@brief Release all resources held by the mbltml library.
 
    After this call, any further API usage requires re-initialization via
    mbltmlInit() or mbltmlInitDevices().
 
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    ret = _clib.mbltmlShutdown()
    _mbltmlThrowError(ret)
 
 
def mbltmlGetDeviceCount() -> int:
    """@brief Get the total number of devices detected by the library.
 
    @note Supported on all device types.
 
    @return The number of devices detected.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDeviceCount(byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetDriverVersion(device_type: mbltmlDeviceType_t) -> str:
    """@brief Get the driver version string for a specific device family.
 
    @note Supported on all device types.
 
    @param device_type Device family whose driver version is queried.
    @return The driver version string.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_DRIVER_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetDriverVersion(
        device_type, buf, MBLTML_DRIVER_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetDriverRevision(device_type: mbltmlDeviceType_t) -> int:
    """@brief Get the driver revision number for a specific device family.
 
    @note Supported on all device types.
 
    @param device_type Device family whose driver revision is queried.
    @return The driver revision number.
    @throws MBLTMLError on failure.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDriverRevision(device_type, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetNodeName(dev_no: int) -> str:
    """@brief Get the node name of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The node name string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_NODE_NAME_BUFFER_SIZE)
    ret = _clib.mbltmlGetNodeName(dev_no, buf, MBLTML_NODE_NAME_BUFFER_SIZE)
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetDeviceType(dev_no: int) -> mbltmlDeviceType_t:
    """@brief Get the device family type of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The mbltmlDeviceType_t of the device.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDeviceType(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetHardwareVersion(dev_no: int) -> mbltmlHardwareVersion_t:
    """@brief Get the hardware version of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The mbltmlHardwareVersion_t of the device.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetHardwareVersion(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetOnDeviceDriverVersion(dev_no: int) -> str:
    """@brief Get the on-device driver version string of a device.
 
    @note Supported on MBLTML_DEVICE_REGULUS_USB only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The on-device driver version string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetOnDeviceDriverVersion(
        dev_no, buf, MBLTML_ON_DEVICE_DRIVER_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetOnDeviceDriverRevision(dev_no: int) -> int:
    """@brief Get the on-device driver revision number of a device.
 
    @note Supported on MBLTML_DEVICE_REGULUS_USB only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The on-device driver revision.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetOnDeviceDriverRevision(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFirmwareVersion(dev_no: int) -> str:
    """@brief Get the firmware version string of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The firmware version string.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    buf = create_string_buffer(MBLTML_FIRMWARE_VERSION_BUFFER_SIZE)
    ret = _clib.mbltmlGetFirmwareVersion(
        dev_no, buf, MBLTML_FIRMWARE_VERSION_BUFFER_SIZE
    )
    _mbltmlThrowError(ret)
    return buf.value.decode()
 
 
def mbltmlGetFirmwareRevision(dev_no: int) -> int:
    """@brief Get the firmware revision number of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The firmware revision.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetFirmwareRevision(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFirmwareCRC(dev_no: int) -> int:
    """@brief Get the CRC of the currently-loaded firmware image.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The firmware CRC.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetFirmwareCRC(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTemperature(dev_no: int) -> int:
    """@brief Get the current die temperature of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The temperature reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int()
    ret = _clib.mbltmlGetTemperature(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSignalType(dev_no: int) -> int:
    """@brief Get the current signal-type indicator reported by the device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The signal-type value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSignalType(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetNPUClock(dev_no: int) -> int:
    """@brief Get the current NPU clock frequency of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The NPU clock value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetNPUClock(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetBusClock(dev_no: int) -> int:
    """@brief Get the current bus clock frequency of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The bus clock value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetBusClock(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetFanDuty(dev_no: int) -> int:
    """@brief Get the current cooling-fan duty cycle of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The fan duty value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int()
    ret = _clib.mbltmlGetFanDuty(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetVendorId(dev_no: int) -> int:
    """@brief Get the PCIe vendor ID of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The vendor ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetVendorId(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetDeviceId(dev_no: int) -> int:
    """@brief Get the PCIe device ID of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The device ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetDeviceId(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSubVendorId(dev_no: int) -> int:
    """@brief Get the PCIe subsystem vendor ID of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The subsystem vendor ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSubVendorId(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetSubDeviceId(dev_no: int) -> int:
    """@brief Get the PCIe subsystem device ID of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The subsystem device ID.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetSubDeviceId(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieGen(dev_no: int) -> int:
    """@brief Get the negotiated PCIe link generation of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The PCIe generation.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieGen(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieLanes(dev_no: int) -> int:
    """@brief Get the negotiated PCIe link width (in lanes) of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The lane count.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieLanes(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieRev(dev_no: int) -> int:
    """@brief Get the PCIe configuration-space revision ID of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The revision value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieRev(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetPcieClassCode(dev_no: int) -> int:
    """@brief Get the PCIe configuration-space class code of a device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The class code.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetPcieClassCode(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalPower(dev_no: int) -> float:
    """@brief Get the total instantaneous power consumption of a device (W).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The power reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalPower(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalCurrent(dev_no: int) -> float:
    """@brief Get the total instantaneous current draw of a device (A).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The current reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalCurrent(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalVoltage(dev_no: int) -> float:
    """@brief Get the total instantaneous supply voltage of a device (V).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The voltage reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalVoltage(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicPower(dev_no: int) -> float:
    """@brief Get the power consumption of the extra PMIC rail currently
           selected for the device (W).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    The selected rail is controlled by mbltmlSetExtraPmicID() and can be
    queried via mbltmlGetExtraPmicId().
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The power reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicPower(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicCurrent(dev_no: int) -> float:
    """@brief Get the current of the extra PMIC rail currently selected
           for the device (A).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The current reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicCurrent(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicVoltage(dev_no: int) -> float:
    """@brief Get the voltage of the extra PMIC rail currently selected
           for the device (V).
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    The firmware refreshes this reading once per second. After changing the
    selected rail with mbltmlSetExtraPmicID(), allow up to 1 second for the
    new rail's value to be reported.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The voltage reading.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetExtraPmicVoltage(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetExtraPmicId(dev_no: int) -> mbltmlExtraPmicId_t:
    """@brief Get the extra PMIC rail currently selected for the device.
 
    @note Supported on MBLTML_DEVICE_ARIES only.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The selected mbltmlExtraPmicId_t value.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_uint()
    ret = _clib.mbltmlGetExtraPmicId(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetTotalUtilization(dev_no: int) -> float:
    """@brief Get the overall NPU utilization of a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The utilization value (typically a ratio in [0.0, 1.0] or a percentage).
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_double()
    ret = _clib.mbltmlGetTotalUtilization(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetMemoryUsage(dev_no: int) -> int:
    """@brief Get the amount of device memory currently in use.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The in-use memory in bytes.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int64()
    ret = _clib.mbltmlGetMemoryUsage(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetMemoryTotal(dev_no: int) -> int:
    """@brief Get the total amount of device memory available.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return The total memory in bytes.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    value = c_int64()
    ret = _clib.mbltmlGetMemoryTotal(dev_no, byref(value))
    _mbltmlThrowError(ret)
    return value.value
 
 
def mbltmlGetProcessInfos(dev_no: int) -> List[mbltmlProcessInfo_t]:
    """@brief Get per-process usage information for a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return List of mbltmlProcessInfo_t records; empty if no process is running.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    c_count = c_uint(0)
    ret = _clib.mbltmlGetProcessInfos(dev_no, None, byref(c_count))
    _mbltmlThrowError(ret)
    if c_count.value == 0:  # No running process
        return []
    c_count.value = c_count.value * 2  # Padding to handle increased process number
    info_array = mbltmlProcessInfo_t * c_count.value
    infos = info_array()
    ret = _clib.mbltmlGetProcessInfos(dev_no, infos, byref(c_count))
    _mbltmlThrowError(ret)
    return [infos[i] for i in range(c_count.value)]
 
 
def mbltmlGetCoreInfos(dev_no: int) -> List[mbltmlCoreInfo_t]:
    """@brief Get per-core usage information for a device.
 
    @note Supported on all device types.
 
    @param dev_no Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @return List of mbltmlCoreInfo_t records.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    c_count = c_uint(0)
    ret = _clib.mbltmlGetCoreInfos(dev_no, None, byref(c_count))
    _mbltmlThrowError(ret)
    if c_count.value == 0:  # No core
        return []
    c_count.value = c_count.value
    info_array = mbltmlCoreInfo_t * c_count.value
    infos = info_array()
    ret = _clib.mbltmlGetCoreInfos(dev_no, infos, byref(c_count))
    _mbltmlThrowError(ret)
    return [infos[i] for i in range(c_count.value)]
 
 
def mbltmlSetExtraPmicID(dev_no: int, pmic_id: mbltmlExtraPmicId_t) -> None:
    """@brief Select which extra PMIC rail subsequent mbltmlGetExtraPmic*() queries refer to.
 
    @note Supported on aries-rb hardware (MBLTML_HARDWARE_VERSION_ARIES_RB) only.
 
    The underlying readings are refreshed by firmware once per second; allow
    up to 1 second after this call before mbltmlGetExtraPmicPower(),
    mbltmlGetExtraPmicCurrent() and mbltmlGetExtraPmicVoltage() reflect the
    newly selected rail.
 
    @param dev_no  Device index. Total device count is obtained via mbltmlGetDeviceCount().
    @param pmic_id Identifier of the extra PMIC rail to select.
    @throws MBLTMLInvalidArgumentError if @p dev_no is out of range of the device count.
    @throws MBLTMLError on other failures.
    """
    _loadLibrary()
    ret = _clib.mbltmlSetExtraPmicID(dev_no, pmic_id)
    _mbltmlThrowError(ret)
 
 