habana-pyhlml 1.10.0.494__py3-none-any.whl

habana_pyhlml-1.10.0.494.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 HabanaAI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

habana_pyhlml-1.10.0.494.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: habana-pyhlml
+Version: 1.10.0.494
+Summary: Python3 wrapper for the HLML library.
+Home-page: UNKNOWN
+Author: HabanaAI
+Author-email: "support@habana.ai"
+License: MIT
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyhlml
+Python3 wrapper for the HLML library
+
+## Getting Started
+
+The pyhlml library is an python API wrapper for the Synapse HLML library, documented here: https://docs.habana.ai/en/latest/API_Reference_Guides/HLML_API_Reference.html
+
+### Requirements
+
+- Python3
+- Habana-enabled device ( inc. Drivers/Firmware )
+- Synapse version 1.0.1-81 or later
+
+### Install - PIP
+
+```bash
+$ pip3 install -e git+https://github.com/HabanaAI/pyhlml.git#egg=pyhlml
+```
+
+### Basic Usage
+
+```python3
+import pyhlml
+
+# Initialize the library
+pyhlml.hlmlInit()
+
+# Get total number of devices in the system
+device_count = pyhlml.hlmlDeviceGetCount()
+
+# For each device print utilization
+for i in range(device_count):
+    device = pyhlml.hlmlDeviceGetHandleByIndex(i)
+    print(f"Device {i} Utilization: {pyhlml.hlmlDeviceGetUtilizationRates(device)}
+
+# Shutdown
+pyhlml.hlmlShutdown()
+```
+
+---
+
+## Versions
+
+This wrapper shadows the synapse release versions and uses the scheme
+
+$release-$build
+
+where release is the synapse release and build is the build of this repo ( 0 indexed ).
+
+
+

habana_pyhlml-1.10.0.494.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyhlml/__init__.py,sha256=VjbHqSSypSMmVK7UTxuCyOs_AE8HhTXX9EGr6NbaQNk,25
+pyhlml/hlml_error.py,sha256=GQulGXf-jX38jEASXF22qJ0yL8eC57vUo8s9lVI7q_E,2113
+pyhlml/hlml_lib.py,sha256=JiHRLl3vpAozhCSs9eJC8xlhIMxR2wNVZdmahjlgDfc,1430
+pyhlml/hlml_types.py,sha256=RESPajQUNWCb0y8KmtyCtwRyKbTYflboOzjMJHY75mo,10630
+pyhlml/main.py,sha256=rCy1nkae5lPmC2nz5PGbp8lVE_1CcZboVqLw1CDrmug,36087
+habana_pyhlml-1.10.0.494.dist-info/LICENSE,sha256=_J8fTEtZF8y69onNU5_EAdOn0AC9RM2uHPh_q36-5bc,1065
+habana_pyhlml-1.10.0.494.dist-info/METADATA,sha256=JyxSH6kA33wOc9rSmhaLfRtrpOcEVJP9Gu_G1FCrePA,1457
+habana_pyhlml-1.10.0.494.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+habana_pyhlml-1.10.0.494.dist-info/top_level.txt,sha256=0jXJHTTotoeuyzpI1dcVr0mzCVB0NKY7LyCF4OwoMZU,7
+habana_pyhlml-1.10.0.494.dist-info/RECORD,,

habana_pyhlml-1.10.0.494.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.38.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

habana_pyhlml-1.10.0.494.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyhlml

pyhlml/__init__.py

@@ -0,0 +1 @@
+from pyhlml.main import *

pyhlml/hlml_error.py

@@ -0,0 +1,50 @@
+from string import capwords
+from sys import modules
+
+import pyhlml.hlml_types as hlml_t
+
+def ErrorsAsClass():
+    this_module = modules[__name__]
+    names = [x for x in dir(hlml_t.HLML_RETURN) if x.startswith("HLML_ERROR")]
+    for err in names:
+        class_name = "HLMLError_" + capwords(err.replace("HLML_ERROR_", ""), "_").replace("_", "")
+        err_v = getattr(hlml_t.HLML_RETURN, err)
+        def gen_new(val):
+            def new(typ):
+                obj = HLMLError.__new__(typ, val)
+                return obj
+            return new
+        new_class = type(class_name, (HLMLError,), {'__new__': gen_new(err_v)})
+        new_class.__module__ = __name__
+        setattr(this_module, class_name, new_class)
+        HLMLError._cMap[err_v] = new_class
+
+class HLMLError(Exception):
+    _cMap = {}
+    _errcodes = {
+        hlml_t.HLML_RETURN.HLML_ERROR_UNINITIALIZED        : "Lib not initialized",
+        hlml_t.HLML_RETURN.HLML_ERROR_INVALID_ARGUMENT     : "Invalid argument",
+        hlml_t.HLML_RETURN.HLML_ERROR_NOT_SUPPORTED        : "Not supported",
+        hlml_t.HLML_RETURN.HLML_ERROR_ALREADY_INITIALIZED  : "Libhlml already initialized",
+        hlml_t.HLML_RETURN.HLML_ERROR_NOT_FOUND            : "Not found",
+        hlml_t.HLML_RETURN.HLML_ERROR_INSUFFICIENT_SIZE    : "Insufficient size",
+        hlml_t.HLML_RETURN.HLML_ERROR_DRIVER_NOT_LOADED    : "Driver not loaded",
+        hlml_t.HLML_RETURN.HLML_ERROR_TIMEOUT              : "Timeout",
+        hlml_t.HLML_RETURN.HLML_ERROR_AIP_IS_LOST          : "AIP Lost",
+        hlml_t.HLML_RETURN.HLML_ERROR_MEMORY               : "Memory error",
+        hlml_t.HLML_RETURN.HLML_ERROR_NO_DATA              : "No Data",
+        hlml_t.HLML_RETURN.HLML_ERROR_UNKNOWN              : "Unknown"
+    }
+
+    def __new__(typ, value):
+        if typ == HLMLError:
+            typ = HLMLError._cMap.get(value, typ)
+        obj = Exception.__new__(typ)
+        obj.value = value
+        return obj
+        
+    def __str__(self):
+        return f"HLML Error with code {self.value}"
+
+    def __eq__(self, other):
+        return self.value == other.value

pyhlml/hlml_lib.py

@@ -0,0 +1,49 @@
+import ctypes
+
+from threading import Lock
+
+from pyhlml.hlml_error import HLMLError
+from pyhlml.hlml_types import HLML_RETURN
+
+class LibHLML:
+    def __init__(self, path="/usr/lib/habanalabs/libhlml.so"):
+        self.default_path   = path
+        self.lib            = None
+        self.lib_load_lock  = Lock()
+        self.func_ptr_cache = dict()
+        self.ref_count      = 0 # INC on init DEC on dest
+
+        self._load_lib()
+
+    def _load_lib(self):
+        with self.lib_load_lock:
+            try:
+                self.lib = ctypes.CDLL(self.default_path)
+            except Exception as e:
+                print("Failed to load libhlml")
+                raise HLMLError(HLML_RETURN.HLML_ERROR_UNINITIALIZED)
+
+    def inc_ref(self):
+        with self.lib_load_lock:
+            self.ref_count += 1
+
+    def dec_ref(self):
+        if self.ref_count > 0:
+            with self.lib_load_lock:
+                self.ref_count -= 1
+
+    def get_func_ptr(self, name):
+        if self.lib == None:
+            raise HLMLError(HLML_RETURN.HLML_ERROR_UNINITIALIZED)
+
+        if name in self.func_ptr_cache:
+            return self.func_ptr_cache[name]
+
+        with self.lib_load_lock:
+            try:
+                self.func_ptr_cache[name] = getattr(self.lib, name)
+                return self.func_ptr_cache[name]
+            except Exception as e:
+                raise HLMLError(HLML_RETURN.HLML_ERROR_INVALID_ARGUMENT)
+
+

pyhlml/hlml_types.py

@@ -0,0 +1,291 @@
+"""
+Python bindings for HLML types
+"""
+
+import ctypes
+
+class HLML_DEVICE:
+    TYPE                                    = ctypes.c_void_p()
+
+class HLML_DEFINE:
+    PCI_DOMAIN_LEN                          = 5
+    PCI_ADDR_LEN                            = ( PCI_DOMAIN_LEN + 10 )
+    PCI_LINK_INFO_LEN                       = 10
+    HL_FIELD_MAX_SIZE                       = 32
+    PORTS_ARR_SIZE                          = 2
+    HLML_DEVICE_ROW_RPL_MAX                 = 32
+    HLML_DEVICE_MAC_MAX_ADDRESSES           = 48
+    HLML_EVENT_ECC_ERR                      = ( 1 << 0 )
+    HLML_EVENT_ECC_DERR                     = ( 1 << 0 )
+    HLML_EVENT_CRITICAL_ERR                 = ( 1 << 1 )
+    HLML_EVENT_CLOCK_RATE                   = ( 1 << 2 )
+    HLML_EVENT_DRAM_ERR                     = ( 1 << 3 )
+    HLML_EVENT_DRAM_DERR                    = ( 1 << 3 )
+    HLML_EVENT_ECC_SERR                     = ( 1 << 4 )
+    HLML_EVENT_DRAM_SERR                    = ( 1 << 5 )
+    HLML_CLOCKS_THROTTLE_REASON_POWER       = ( 1 << 0 )
+    HLML_CLOCKS_THROTTLE_REASON_THERMAL     = ( 1 << 1 )
+    HLML_AFFINITY_SCOPE_NODE                = 0
+    HLML_AFFINITY_SCOPE_SOCKET              = 1
+
+class COMMON_DEFINE:
+    VERSION_MAX_LEN                         = 128
+    ETHER_ADDR_LEN                          = 6
+    HABANA_LINK_CNT_MAX_NUM                 = 256
+
+class HLML_AFFINITY_SCOPE:
+    TYPE                                    = ctypes.c_uint()
+    HLML_AFFINITY_SCOPE_NODE                = 0
+    HLML_AFFINITY_SCOPE_SOCKET              = 1
+
+class HLML_RETURN:
+    TYPE                                    = ctypes.c_uint()
+    HLML_SUCCESS                            = 0
+    HLML_ERROR_UNINITIALIZED                = 1
+    HLML_ERROR_INVALID_ARGUMENT             = 2
+    HLML_ERROR_NOT_SUPPORTED                = 3
+    HLML_ERROR_ALREADY_INITIALIZED          = 5
+    HLML_ERROR_NOT_FOUND                    = 6
+    HLML_ERROR_INSUFFICIENT_SIZE            = 7
+    HLML_ERROR_DRIVER_NOT_LOADED            = 9
+    HLML_ERROR_TIMEOUT                      = 10
+    HLML_ERROR_AIP_IS_LOST                  = 15
+    HLML_ERROR_MEMORY                       = 20
+    HLML_ERROR_NO_DATA                      = 21
+    HLML_ERROR_UNKNOWN                      = 49
+
+class HLML_CLOCK_TYPE:
+    TYPE                                    = ctypes.c_uint()
+    HLML_CLOCK_SOC                          = 0
+    HLML_CLOCK_IC                           = 1
+    HLML_CLOCK_MME                          = 2
+    HLML_CLOCK_TPC                          = 3
+    HLML_CLOCK_COUNT                        = 4
+
+class HLML_TEMP_SENS:
+    TYPE                                    = ctypes.c_uint()
+    HLML_TEMPERATURE_ON_AIP                 = 0
+    HLML_TEMPERATURE_ON_BOARD               = 1
+    HLML_TEMPERATURE_OTHER                  = 2
+
+class HLML_TEMP_THRESH:
+    TYPE                                    = ctypes.c_uint()
+    HLML_TEMPERATURE_THRESHOLD_SHUTDOWN     = 0
+    HLML_TEMPERATURE_THRESHOLD_SLOWDOWN     = 1
+    HLML_TEMPERATURE_THRESHOLD_MEM_MAX      = 2
+    HLML_TEMPERATURE_THRESHOLD_GPU_MAX      = 3
+    HLML_TEMPERATURE_THRESHOLD_COUNT        = 4
+
+class HLML_ENABLE_STATE:
+    TYPE                                    = ctypes.c_uint()
+    HLML_FEATURE_DISABLED                   = 0
+    HLML_FEATURE_ENABLED                    = 1
+
+class HLML_P_STATES:
+    TYPE                                    = ctypes.c_uint()
+    HLML_PSTATE_0                           = 0
+    HLML_PSTATE_UNKNOWN                     = 32
+
+class HLML_MEMORY_ERROR:
+    TYPE                                    = ctypes.c_uint()
+    HLML_MEMORY_ERROR_TYPE_CORRECTED        = 0 # NOT SUPPORTED BY HLML
+    HLML_MEMORY_ERROR_TYPE_UNCORRECTED      = 1
+    HLML_MEMORY_ERROR_TYPE_COUNT            = 2
+
+class HLML_MEMORY_LOCATION:
+    TYPE                                    = ctypes.c_uint()
+    HLML_MEMORY_LOCATION_SRAM               = 0
+    HLML_MEMORY_LOCATION_DRAM               = 1
+    HLML_MEMORY_LOCATION_COUNT              = 2
+
+class HLML_ECC_COUNTER:
+    TYPE                                    = ctypes.c_uint()
+    HLML_VOLATILE_ECC                       = 0
+    HLML_AGGREGATE_ECC                      = 1
+    HLML_ECC_COUNTER_TYPE_COUNT             = 2
+
+class HLML_ERR_INJECT:
+    TYPE                                    = ctypes.c_uint()
+    HLML_ERR_INJECT_ENDLESS_COMMAND         = 0
+    HLML_ERR_INJECT_NON_FATAL_EVENT         = 1
+    HLML_ERR_INJECT_FATAL_EVENT             = 2
+    HLML_ERR_INJECT_LOSS_OF_HEARTBEAT       = 3
+    HLML_ERR_INJECT_THERMAL_EVENT           = 4
+    HLML_ERR_INJECT_COUNT                   = 5
+
+class HLML_PCIE_UTIL_COUNTER:
+    TYPE                                    = ctypes.c_uint()
+    HLML_PCIE_UTIL_TX_BYTES                 = 0
+    HLML_PCIE_UTIL_RX_BYTES                 = 1
+    HLML_PCIE_UTIL_COUNT                    = 2
+    
+class HLML_EVENT_SET:
+    TYPE                                    = ctypes.c_void_p()
+
+class HLML_ROW_REPLACEMENT_CAUSE:
+    TYPE                                                      = ctypes.c_uint()
+    HLML_ROW_REPLACEMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS = 0,
+    HLML_ROW_REPLACEMENT_CAUSE_DOUBLE_BIT_ECC_ERROR           = 1,
+    HLML_ROW_REPLACEMENT_CAUSE_COUNT                          = 2
+
+class HLML_PERF_POLICY:
+    TYPE                                    = ctypes.c_uint()
+    HLML_PERF_POLICY_POWER                  = 0,
+    HLML_PERF_POLICY_THERMAL                = 1,
+    HLML_PERF_POLICY_COUNT                  = 0
+
+class _struct_c_hlml_unit(ctypes.Structure):
+    pass # opaque handle
+
+class HLML_UNIT:
+    TYPE                                    = _struct_c_hlml_unit()
+
+class _PrintS(ctypes.Structure):
+    """
+    Produces nicer __str__ output than ctypes.Structure.
+    
+    e.g. instead of:
+      
+    > print str(obj)
+    <class_name object at 0x7fdf82fef9e0>
+    
+    this class will print...
+
+    > print str(obj)
+    class_name(field_name: formatted_value, field_name: formatted_value)
+    _fmt_ dictionary of <str _field_ name> -> <str format>
+    
+    Default formatting string for all fields can be set with key "<default>" like:
+      _fmt_ = {"<default>" : "%d MHz"} # e.g all values are numbers in MHz.
+
+    If not set it's assumed to be just "%s"
+
+    e.g. class that has _field_ 'hex_value', c_uint could be formatted with
+      _fmt_ = {"hex_value" : "%08X"}
+    to produce nicer output.
+    """
+    _fmt_ = {}
+    def __str__(self):
+        result = []
+        for x in self._fields_:
+            key = x[0]
+            value = getattr(self, key)
+            fmt = "%s"
+            if key in self._fmt_:
+                fmt = self._fmt_[key]
+            elif "<default>" in self._fmt_:
+                fmt = self._fmt_["<default>"]
+            result.append(("%s: " + fmt) % (key, value))
+        return self.__class__.__name__ + "(" +  ", ".join(result) + ")"
+
+class c_hlml_pci_cap(_PrintS):
+    _fields_ = [("link_speed", ctypes.c_char * HLML_DEFINE.PCI_LINK_INFO_LEN),
+                ("link_width",ctypes.c_char * HLML_DEFINE.PCI_LINK_INFO_LEN)
+               ]
+
+class c_hlml_pci_info(_PrintS):
+    """
+    /*
+        * bus - The bus on which the device resides, 0 to 0xf
+        * bus_id - The tuple domain:bus:device.function
+        * device - The device's id on the bus, 0 to 31
+        * domain - The PCI domain on which the device's bus resides
+        * pci_device_id - The combined 16b deviceId and 16b vendor id
+    */
+    """
+    _fields_ = [("bus", ctypes.c_uint),
+                ("bus_id", ctypes.c_char * HLML_DEFINE.PCI_ADDR_LEN),
+                ("device", ctypes.c_uint),
+                ("domain", ctypes.c_uint),
+                ("pci_device_id", ctypes.c_uint),
+                ("caps", c_hlml_pci_cap)
+               ]
+
+class c_hlml_utilization(_PrintS):
+    _fields_ = [("aip", ctypes.c_uint)]
+
+class c_hlml_memory(_PrintS):
+    _fields_ = [("free", ctypes.c_ulonglong),
+                ("total", ctypes.c_ulonglong),
+                ("used", ctypes.c_ulonglong)
+               ]
+
+class c_hlml_pcb_info(_PrintS):
+    _fields_ = [("pcb_ver", ctypes.c_char * HLML_DEFINE.HL_FIELD_MAX_SIZE),
+                ("pcb_assembly_ver", ctypes.c_char * HLML_DEFINE.HL_FIELD_MAX_SIZE)
+               ]
+
+class c_hlml_event_data(_PrintS):
+    _fields_ = [("device", ctypes.c_void_p),
+                ("event_type", ctypes.c_ulonglong)
+               ]
+
+class c_hlml_mac_info(_PrintS):
+    _fields_ = [("addr", ctypes.c_ubyte * COMMON_DEFINE.ETHER_ADDR_LEN), # unsigned char
+                ("id", ctypes.c_int)
+               ]
+
+class c_hlml_nic_stats_info(_PrintS):
+    _fields_ = [("port", ctypes.c_uint32),
+                ("str_buf", ctypes.POINTER(ctypes.c_char)),
+                ("val_buf", ctypes.POINTER(ctypes.c_uint64)),
+                ("num_of_counters_out", ctypes.POINTER(ctypes.c_uint32))
+                ]
+
+    def __init__(self, port: int, num_of_counters: int = None):
+        num_of_counters = num_of_counters or COMMON_DEFINE.HABANA_LINK_CNT_MAX_NUM
+        self.port = port
+
+        str_buf_size = num_of_counters * 32
+        self.str_buf = ctypes.cast(ctypes.create_string_buffer(str_buf_size), ctypes.POINTER(ctypes.c_char))
+
+        val_buf_size = num_of_counters * ctypes.sizeof(ctypes.c_uint64)
+        self.val_buf = (ctypes.c_uint64 * val_buf_size)()
+
+        self.num_of_counters_out = (ctypes.c_uint32 * 1)()
+
+class c_hlml_violation_time(_PrintS):
+    _fields_ = [("reference_time", ctypes.c_ulonglong),
+                ("violation_time", ctypes.c_ulonglong)
+               ]
+
+class c_hlml_row_address(_PrintS):
+    _fields_ = [("hbm_idx", ctypes.c_uint8),
+                ("pc", ctypes.c_uint8),
+                ("sid", ctypes.c_uint8),
+                ("bank_idx", ctypes.c_uint8),
+                ("row_addr", ctypes.c_uint16)
+               ]
+
+class hlml_ecc_mode(_PrintS):
+    _fields_ = [("current", ctypes.c_uint), 
+                ("pending", ctypes.c_uint)
+               ]
+
+## Alternative object
+# Allows the object to be printed
+# Allows mismatched types to be assigned
+#  - like None when the Structure variant requires c_uint
+
+class hlml_friendly_obj(object):
+    def __init__(self, dic):
+        for x in dic:
+            setattr(self, x, dic[x])
+    def __str__(self):
+        return self.__dict__.__str__()
+
+def hlml_struct_to_friendly(struct):
+    dic = {}
+    for x in struct._fields_:
+        key = x[0]
+        value = getattr(struct, key)
+        dic[key] = value
+    obj = hlml_friendly_obj(dic)
+    return obj
+
+def hlml_friendly_to_struct(obj, model):
+    for x in model._fields_:
+        key = x[0]
+        value = obj.__dict__[key]
+        setattr(model, key, value)
+    return model