Merge branch 'master' into master

Author: aviralni

bindings/sysman/python/source/examples/pyzes_black_box_test.py

@@ -1096,6 +1096,28 @@ def test_frequency_domains(device_handle, device_index):
     for i in range(freq_count.value):
         print_verbose(f"\n  Frequency Domain {i}:")
 
+        freq_properties = pz.zes_freq_properties_t()
+        freq_properties.stype = pz.ZES_STRUCTURE_TYPE_FREQ_PROPERTIES
+        freq_properties.pNext = None
+
+        rc = pz.zesFrequencyGetProperties(freq_handles[i], byref(freq_properties))
+        if not check_rc(f"zesFrequencyGetProperties(frequency {i})", rc):
+            continue
+
+        print_verbose("    Frequency Properties:")
+        print_verbose(
+            f"      Type: {get_frequency_domain_string(freq_properties.type)}"
+        )
+        print_verbose(f"      Can Control: {bool(freq_properties.canControl)}")
+        print_verbose(
+            "      Throttle Event Supported: "
+            f"{bool(freq_properties.isThrottleEventSupported)}"
+        )
+        print_verbose(f"      Minimum Frequency: {freq_properties.min:.1f} MHz")
+        print_verbose(f"      Maximum Frequency: {freq_properties.max:.1f} MHz")
+        if freq_properties.onSubdevice:
+            print_verbose(f"      Subdevice ID: {freq_properties.subdeviceId}")
+
         available_clock_count = c_uint32(0)
         rc = pz.zesFrequencyGetAvailableClocks(
             freq_handles[i], byref(available_clock_count), None

bindings/sysman/python/source/pyzes.py

@@ -673,6 +673,21 @@ class zes_power_energy_counter_t(_PrintableStructure):
 
 
 ## Frequency structures ##
+class zes_freq_properties_t(_PrintableStructure):
+    _fields_ = [
+        ("stype", c_int32),
+        ("pNext", c_void_p),
+        ("type", zes_freq_domain_t),
+        ("onSubdevice", ze_bool_t),
+        ("subdeviceId", c_uint32),
+        ("canControl", ze_bool_t),
+        ("isThrottleEventSupported", ze_bool_t),
+        ("min", c_double),
+        ("max", c_double),
+    ]
+    _fmt_ = {"min": "%.1f MHz", "max": "%.1f MHz"}
+
+
 class zes_freq_range_t(_PrintableStructure):
     _fields_ = [
         ("min", c_double),
@@ -1274,6 +1289,26 @@ def zesDeviceEnumFrequencyDomains(hDevice, pCount, phFrequency):
     return retVal
 
 
+def zesFrequencyGetProperties(hFrequency, pProperties):
+    """Wraps API:
+    ze_result_t zesFrequencyGetProperties(
+            zes_freq_handle_t hFrequency,
+            zes_freq_properties_t* pProperties)
+
+    Parameters:
+        hFrequency: frequency handle
+        pProperties: POINTER(zes_freq_properties_t) - properties structure to fill
+    Returns:
+        ze_result_t - return code only, properties are filled into pProperties
+    """
+    funcPtr = getFunctionPointerList("zesFrequencyGetProperties")
+    funcPtr.argtypes = [zes_freq_handle_t, POINTER(zes_freq_properties_t)]
+    funcPtr.restype = ze_result_t
+
+    retVal = funcPtr(hFrequency, pProperties)
+    return retVal
+
+
 def zesFrequencyGetState(hFrequency, pState):
     """Wraps API:
     ze_result_t zesFrequencyGetState(

bindings/sysman/python/test/unit_tests/test_frequency.py

@@ -50,6 +50,52 @@ def mock_enum_frequency_domains(device_handle, count_ptr, handles_ptr):
         mock_get_func.assert_called_with("zesDeviceEnumFrequencyDomains")
         mock_func.assert_called_once()
 
+    def test_GivenValidFrequencyHandleWhenCallingZesFrequencyGetPropertiesThenCallSucceedsWithProperties(
+        self, mock_get_func
+    ):
+        mock_type = self.pyzes.ZES_FREQ_DOMAIN_GPU
+        mock_on_subdevice = True
+        mock_subdevice_id = 1
+        mock_can_control = True
+        mock_is_throttle_event_supported = True
+        mock_min = 300.0
+        mock_max = 1800.0
+
+        def mock_get_properties(frequency_handle, properties_ptr):
+            properties_ptr._obj.type = mock_type
+            properties_ptr._obj.onSubdevice = mock_on_subdevice
+            properties_ptr._obj.subdeviceId = mock_subdevice_id
+            properties_ptr._obj.canControl = mock_can_control
+            properties_ptr._obj.isThrottleEventSupported = (
+                mock_is_throttle_event_supported
+            )
+            properties_ptr._obj.min = mock_min
+            properties_ptr._obj.max = mock_max
+            return self.pyzes.ZE_RESULT_SUCCESS
+
+        mock_func = MagicMock(side_effect=mock_get_properties)
+        mock_get_func.return_value = mock_func
+
+        frequency_handle = self.pyzes.zes_freq_handle_t()
+        properties = self.pyzes.zes_freq_properties_t()
+
+        result = self.pyzes.zesFrequencyGetProperties(
+            frequency_handle, byref(properties)
+        )
+
+        self.assertEqual(result, self.pyzes.ZE_RESULT_SUCCESS)
+        self.assertEqual(properties.type, mock_type)
+        self.assertEqual(properties.onSubdevice, mock_on_subdevice)
+        self.assertEqual(properties.subdeviceId, mock_subdevice_id)
+        self.assertEqual(properties.canControl, mock_can_control)
+        self.assertEqual(
+            properties.isThrottleEventSupported, mock_is_throttle_event_supported
+        )
+        self.assertEqual(properties.min, mock_min)
+        self.assertEqual(properties.max, mock_max)
+        mock_get_func.assert_called_with("zesFrequencyGetProperties")
+        mock_func.assert_called_once()
+
     def test_GivenValidFrequencyHandleWhenCallingZesFrequencyGetStateThenCallSucceedsWithState(
         self, mock_get_func
     ):