feature(sysman): Added support for Performance APIs

Added support for the Performance APIs in the new sysman design.
Added ULTs for the Performance APIs in the new sysman design.
In the black box test for performance, the API to compute the number
of sub devices has been changed in order to get the sub device count
regardless of the sysman initialization using zeInit or zesInit.

Related-To: LOCI-4294

Signed-off-by: Bari, Pratik <pratik.bari@intel.com>

level_zero/api/sysman/zes_handles_struct.h

@@ -50,4 +50,7 @@ struct _zes_standby_handle_t {
 
 struct _zes_temp_handle_t {
     virtual ~_zes_temp_handle_t() = default;
-};
+};
+struct _zes_perf_handle_t {
+    virtual ~_zes_perf_handle_t() = default;
+};

level_zero/api/sysman/zes_sysman_api_entrypoints.h

@@ -954,25 +954,41 @@ ze_result_t zesDeviceEnumPerformanceFactorDomains(
     zes_device_handle_t hDevice,
     uint32_t *pCount,
     zes_perf_handle_t *phPerf) {
-    return L0::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    if (L0::sysmanInitFromCore) {
+        return L0::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    } else {
+        return L0::Sysman::SysmanDevice::performanceGet(hDevice, pCount, phPerf);
+    }
 }
 
 ze_result_t zesPerformanceFactorGetProperties(
     zes_perf_handle_t hPerf,
     zes_perf_properties_t *pProperties) {
-    return L0::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceGetProperties(pProperties);
+    }
 }
 
 ze_result_t zesPerformanceFactorGetConfig(
     zes_perf_handle_t hPerf,
     double *pFactor) {
-    return L0::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceGetConfig(pFactor);
+    }
 }
 
 ze_result_t zesPerformanceFactorSetConfig(
     zes_perf_handle_t hPerf,
     double factor) {
-    return L0::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    if (L0::sysmanInitFromCore) {
+        return L0::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    } else {
+        return L0::Sysman::Performance::fromHandle(hPerf)->performanceSetConfig(factor);
+    }
 }
 
 ze_result_t zesDeviceEccAvailable(

level_zero/sysman/source/performance/CMakeLists.txt

@@ -0,0 +1,17 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${L0_STATIC_LIB_NAME}
+               PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance_imp.cpp
+               ${CMAKE_CURRENT_SOURCE_DIR}/performance_imp.h
+               ${CMAKE_CURRENT_SOURCE_DIR}/os_performance.h
+)
+
+add_subdirectories()

level_zero/sysman/source/performance/linux/CMakeLists.txt

@@ -0,0 +1,26 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(UNIX)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  )
+
+  if(NEO_ENABLE_i915_PRELIM_DETECTION)
+    target_sources(${L0_STATIC_LIB_NAME}
+                   PRIVATE
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp_prelim.cpp
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp_prelim.h
+    )
+  else()
+    target_sources(${L0_STATIC_LIB_NAME}
+                   PRIVATE
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.cpp
+                   ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.h
+    )
+  endif()
+endif()

level_zero/sysman/source/performance/linux/os_performance_imp.cpp

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/linux/os_performance_imp.h"
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetProperties(zes_perf_properties_t &pProperties) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetConfig(double *pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceSetConfig(double pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool LinuxPerformanceImp::isPerformanceSupported(void) {
+    return false;
+}
+
+OsPerformance *OsPerformance::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain) {
+    LinuxPerformanceImp *pLinuxPerformanceImp = new LinuxPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain);
+    return static_cast<OsPerformance *>(pLinuxPerformanceImp);
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/linux/os_performance_imp.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/linux/os_sysman_imp.h"
+#include "level_zero/sysman/source/performance/os_performance.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+class LinuxPerformanceImp : public OsPerformance, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t osPerformanceGetProperties(zes_perf_properties_t &pProperties) override;
+    ze_result_t osPerformanceGetConfig(double *pFactor) override;
+    ze_result_t osPerformanceSetConfig(double pFactor) override;
+
+    bool isPerformanceSupported(void) override;
+
+    LinuxPerformanceImp() = delete;
+    LinuxPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                        zes_engine_type_flag_t domain) {}
+    ~LinuxPerformanceImp() override = default;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/linux/os_performance_imp_prelim.cpp

@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/linux/os_performance_imp_prelim.h"
+
+#include "shared/source/debug_settings/debug_settings_manager.h"
+#include "shared/source/device/device.h"
+#include "shared/source/helpers/hw_info.h"
+
+#include "level_zero/sysman/source/sysman_const.h"
+
+#include <cmath>
+
+namespace L0 {
+namespace Sysman {
+
+const std::string LinuxPerformanceImp::sysPwrBalance("sys_pwr_balance");
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetProperties(zes_perf_properties_t &pProperties) {
+    pProperties.onSubdevice = isSubdevice;
+    pProperties.subdeviceId = subdeviceId;
+    pProperties.engines = domain;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::getBaseScaleFactor() {
+    auto result = pSysfsAccess->read(baseScale, baseScaleReading);
+    if (ZE_RESULT_SUCCESS != result) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, baseScale.c_str(), getErrorCode(result));
+        return getErrorCode(result);
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::getMediaScaleFactor() {
+    auto result = pSysfsAccess->read(mediaScale, mediaScaleReading);
+    if (ZE_RESULT_SUCCESS != result) {
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, mediaScale.c_str(), getErrorCode(result));
+        return getErrorCode(result);
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceGetConfig(double *pFactor) {
+    ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    double baseFactorReading = 0;
+    double mediaFactorReading = 0;
+    double sysPwrBalanceReading = 0;
+    double multiplier = 0;
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        result = pSysfsAccess->read(sysPwrBalance, sysPwrBalanceReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, sysPwrBalance.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        if (sysPwrBalanceReading >= 0 && sysPwrBalanceReading <= 16.0) {
+            *pFactor = 50.0 + std::round((16.0 - sysPwrBalanceReading) * 50.0 / 16.0);
+        } else if (sysPwrBalanceReading > 16.0 && sysPwrBalanceReading <= 63.0) {
+            *pFactor = std::round((63.0 - sysPwrBalanceReading) * 50.0 / (63.0 - 16.0));
+        } else {
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        result = pSysfsAccess->read(mediaFreqFactor, mediaFactorReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, mediaFreqFactor.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        multiplier = (mediaFactorReading * mediaScaleReading); // Value retrieved from media_freq_factor file is in U(fixed point decimal) format convert it into decimal by multiplication with scale factor
+        if (multiplier == 1) {
+            *pFactor = maxPerformanceFactor;
+        } else if (multiplier == 0.5) {
+            *pFactor = halfOfMaxPerformanceFactor;
+        } else if (multiplier == 0) {
+            *pFactor = minPerformanceFactor;
+        } else {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): multiplier for MEDIA is not matching with given presets and returning UNKNOWN ERROR \n", __FUNCTION__);
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        result = pSysfsAccess->read(baseFreqFactor, baseFactorReading);
+        if (ZE_RESULT_SUCCESS != result) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): SysfsAccess->read() failed to read %s and returning error:0x%x \n", __FUNCTION__, baseFreqFactor.c_str(), getErrorCode(result));
+            return getErrorCode(result);
+        }
+        multiplier = (baseFactorReading * baseScaleReading); // Value retrieved from base_freq_factor file is in U(fixed point decimal) format convert it into decimal by multiplication with scale factor
+        if (multiplier >= 0.5 && multiplier <= 1) {
+            *pFactor = (1 - multiplier) * 100 + 50;
+        } else if (multiplier > 1 && multiplier <= 2) {
+            *pFactor = (2 - multiplier) * 50;
+        } else {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): multiplier for COMPUTE is not matching with given presets and returning UNKNOWN ERROR\n", __FUNCTION__);
+            result = ZE_RESULT_ERROR_UNKNOWN;
+        }
+        break;
+    default:
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        break;
+    }
+    return result;
+}
+
+ze_result_t LinuxPerformanceImp::osPerformanceSetConfig(double pFactor) {
+    double multiplier = 0;
+    ze_result_t result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+    if (pFactor < minPerformanceFactor || pFactor > maxPerformanceFactor) {
+        return ZE_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        if (pFactor <= halfOfMaxPerformanceFactor) {
+            multiplier = 63.0 - std::round(pFactor * (47.0) / 50.0); // multiplier = 63 - ROUND(pFactor * (63.0 - 16.0) / 50.0)
+        } else {
+            multiplier = 16.0 - std::round((pFactor - 50.0) * 16.0 / 50.0);
+        }
+        result = pSysfsAccess->write(sysPwrBalance, multiplier);
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        if (productFamily == IGFX_PVC) {
+            if (pFactor > halfOfMaxPerformanceFactor) {
+                multiplier = 1;
+            } else {
+                multiplier = 0.5;
+            }
+        } else {
+            if (pFactor > halfOfMaxPerformanceFactor) {
+                multiplier = 1;
+            } else if (pFactor > minPerformanceFactor) {
+                multiplier = 0.5;
+            } else {
+                multiplier = 0; // dynamic control mode is not supported on PVC
+            }
+        }
+        multiplier = multiplier / mediaScaleReading; // Divide by scale factor and then round off to convert from decimal to U format
+        multiplier = std::round(multiplier);
+        result = pSysfsAccess->write(mediaFreqFactor, multiplier);
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        if (pFactor < halfOfMaxPerformanceFactor) {
+            multiplier = 2 - (pFactor / 50.0);
+        } else {
+            multiplier = 1 - ((pFactor - 50) / 100.0);
+        }
+        multiplier = multiplier / baseScaleReading; // Divide by scale factor and then round off to convert from decimal to U format
+        multiplier = std::round(multiplier);
+        result = pSysfsAccess->write(baseFreqFactor, multiplier);
+        break;
+    default:
+        NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s() returning UNSUPPORTED_FEATURE \n", __FUNCTION__);
+        result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        break;
+    }
+
+    return result;
+}
+
+bool LinuxPerformanceImp::isPerformanceSupported(void) {
+    switch (domain) {
+    case ZES_ENGINE_TYPE_FLAG_OTHER:
+        if (pSysfsAccess->canRead(sysPwrBalance) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_OTHER returns false \n", __FUNCTION__);
+            return false;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_MEDIA:
+        if (pSysfsAccess->canRead(mediaFreqFactor) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_MEDIA returns false \n", __FUNCTION__);
+            return false;
+        }
+        if (getMediaScaleFactor() != ZE_RESULT_SUCCESS) {
+            return false;
+        }
+        break;
+    case ZES_ENGINE_TYPE_FLAG_COMPUTE:
+        if (pSysfsAccess->canRead(baseFreqFactor) != ZE_RESULT_SUCCESS) {
+            NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr, "Error@ %s(): ZES_ENGINE_TYPE_FLAG_COMPUTE returns false \n", __FUNCTION__);
+            return false;
+        }
+        if (getBaseScaleFactor() != ZE_RESULT_SUCCESS) {
+            return false;
+        }
+        break;
+    default:
+        return false;
+        break;
+    }
+    return true;
+}
+
+void LinuxPerformanceImp::init() {
+    const std::string baseDir = "gt/gt" + std::to_string(subdeviceId) + "/";
+    baseFreqFactor = baseDir + "base_freq_factor";
+    mediaFreqFactor = baseDir + "media_freq_factor";
+    baseScale = baseDir + "base_freq_factor.scale";
+    mediaScale = baseDir + "media_freq_factor.scale";
+}
+
+LinuxPerformanceImp::LinuxPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                                         zes_engine_type_flag_t domain) : domain(domain), subdeviceId(subdeviceId), isSubdevice(onSubdevice) {
+    LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
+    pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
+    productFamily = pLinuxSysmanImp->getProductFamily();
+    init();
+}
+
+OsPerformance *OsPerformance::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain) {
+    LinuxPerformanceImp *pLinuxPerformanceImp = new LinuxPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain);
+    return static_cast<OsPerformance *>(pLinuxPerformanceImp);
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/linux/os_performance_imp_prelim.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/linux/fs_access.h"
+#include "level_zero/sysman/source/linux/os_sysman_imp.h"
+#include "level_zero/sysman/source/performance/os_performance.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+class SysfsAccess;
+class LinuxPerformanceImp : public OsPerformance, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t osPerformanceGetProperties(zes_perf_properties_t &pProperties) override;
+    ze_result_t osPerformanceGetConfig(double *pFactor) override;
+    ze_result_t osPerformanceSetConfig(double pFactor) override;
+
+    bool isPerformanceSupported(void) override;
+
+    LinuxPerformanceImp() = delete;
+    LinuxPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                        zes_engine_type_flag_t domain);
+    ~LinuxPerformanceImp() override = default;
+
+  protected:
+    L0::Sysman::SysfsAccess *pSysfsAccess = nullptr;
+    zes_engine_type_flag_t domain = ZES_ENGINE_TYPE_FLAG_OTHER;
+
+  private:
+    std::string mediaFreqFactor;
+    std::string baseFreqFactor;
+    static const std::string sysPwrBalance;
+    std::string baseScale;
+    std::string mediaScale;
+    uint32_t subdeviceId = 0;
+    ze_bool_t isSubdevice = 0;
+    double baseScaleReading = 0;
+    double mediaScaleReading = 0;
+    PRODUCT_FAMILY productFamily{};
+    ze_result_t getMediaFreqFactor();
+    ze_result_t getMediaScaleFactor();
+    ze_result_t getBaseFreqFactor();
+    ze_result_t getBaseScaleFactor();
+    void init();
+    void getMultiplierVal(double rp0Reading, double rpnReading, double pFactor, double &multiplier);
+    void getPerformanceFactor(double rp0Reading, double rpnReading, double multiplierReading, double *pFactor);
+    ze_result_t getErrorCode(ze_result_t result) {
+        if (result == ZE_RESULT_ERROR_NOT_AVAILABLE) {
+            result = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+        }
+        return result;
+    }
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/os_performance.h

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "level_zero/sysman/source/os_sysman.h"
+#include <level_zero/zes_api.h>
+
+namespace L0 {
+namespace Sysman {
+
+class OsPerformance {
+  public:
+    virtual ze_result_t osPerformanceGetProperties(zes_perf_properties_t &pProperties) = 0;
+    virtual ze_result_t osPerformanceGetConfig(double *pFactor) = 0;
+    virtual ze_result_t osPerformanceSetConfig(double pFactor) = 0;
+
+    virtual bool isPerformanceSupported(void) = 0;
+
+    static OsPerformance *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain);
+    virtual ~OsPerformance() {}
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/performance.cpp

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/performance.h"
+
+#include "level_zero/sysman/source/os_sysman.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+#include <algorithm>
+
+namespace L0 {
+namespace Sysman {
+
+PerformanceHandleContext::~PerformanceHandleContext() {
+    for (auto &pPerformance : handleList) {
+        if (pPerformance) {
+            delete pPerformance;
+            pPerformance = nullptr;
+        }
+        handleList.pop_back();
+    }
+}
+
+void PerformanceHandleContext::createHandle(bool onSubdevice, uint32_t subDeviceId, zes_engine_type_flag_t domain) {
+    Performance *pPerformance = new PerformanceImp(pOsSysman, onSubdevice, subDeviceId, domain);
+    if (pPerformance->isPerformanceEnabled == true) {
+        handleList.push_back(pPerformance);
+    } else {
+        delete pPerformance;
+    }
+}
+
+ze_result_t PerformanceHandleContext::init(uint32_t subDeviceCount) {
+
+    if (subDeviceCount > 0) {
+        for (uint32_t subDeviceId = 0; subDeviceId < subDeviceCount; subDeviceId++) {
+            createHandle(true, subDeviceId, ZES_ENGINE_TYPE_FLAG_MEDIA);
+            createHandle(true, subDeviceId, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+        }
+
+    } else {
+        createHandle(false, 0, ZES_ENGINE_TYPE_FLAG_MEDIA);
+        createHandle(false, 0, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+    }
+
+    createHandle(false, 0, ZES_ENGINE_TYPE_FLAG_OTHER);
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t PerformanceHandleContext::performanceGet(uint32_t *pCount, zes_perf_handle_t *phPerformance) {
+    std::call_once(initPerformanceOnce, [this]() {
+        this->init(pOsSysman->getSubDeviceCount());
+    });
+    uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
+    uint32_t numToCopy = std::min(*pCount, handleListSize);
+    if (0 == *pCount || *pCount > handleListSize) {
+        *pCount = handleListSize;
+    }
+    if (nullptr != phPerformance) {
+        for (uint32_t i = 0; i < numToCopy; i++) {
+            phPerformance[i] = handleList[i]->toPerformanceHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/performance.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/api/sysman/zes_handles_struct.h"
+#include <level_zero/zes_api.h>
+
+#include <mutex>
+#include <vector>
+
+namespace L0 {
+namespace Sysman {
+
+struct OsSysman;
+
+class Performance : _zes_perf_handle_t {
+  public:
+    ~Performance() override {}
+    virtual ze_result_t performanceGetProperties(zes_perf_properties_t *pProperties) = 0;
+    virtual ze_result_t performanceGetConfig(double *pFactor) = 0;
+    virtual ze_result_t performanceSetConfig(double pFactor) = 0;
+
+    inline zes_perf_handle_t toPerformanceHandle() { return this; }
+
+    static Performance *fromHandle(zes_perf_handle_t handle) {
+        return static_cast<Performance *>(handle);
+    }
+    bool isPerformanceEnabled = false;
+};
+
+struct PerformanceHandleContext {
+    PerformanceHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
+    ~PerformanceHandleContext();
+
+    ze_result_t init(uint32_t subDeviceCount);
+
+    ze_result_t performanceGet(uint32_t *pCount, zes_perf_handle_t *phPerformance);
+
+    OsSysman *pOsSysman = nullptr;
+    std::vector<Performance *> handleList = {};
+
+  private:
+    void createHandle(bool onSubdevice, uint32_t subDeviceId, zes_engine_type_flag_t domain);
+    std::once_flag initPerformanceOnce;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/performance_imp.cpp

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+#include "shared/source/helpers/debug_helpers.h"
+
+#include "level_zero/sysman/source/sysman_device_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t PerformanceImp::performanceGetProperties(zes_perf_properties_t *pProperties) {
+    *pProperties = performanceProperties;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t PerformanceImp::performanceGetConfig(double *pFactor) {
+    return pOsPerformance->osPerformanceGetConfig(pFactor);
+}
+
+ze_result_t PerformanceImp::performanceSetConfig(double pFactor) {
+    return pOsPerformance->osPerformanceSetConfig(pFactor);
+}
+
+void PerformanceImp::init() {
+    this->isPerformanceEnabled = pOsPerformance->isPerformanceSupported();
+    if (this->isPerformanceEnabled) {
+        pOsPerformance->osPerformanceGetProperties(performanceProperties);
+    }
+}
+
+PerformanceImp::PerformanceImp(OsSysman *pOsSysman, bool onSubdevice, uint32_t subDeviceId, zes_engine_type_flag_t domain) {
+    pOsPerformance = OsPerformance::create(pOsSysman, onSubdevice,
+                                           subDeviceId, domain);
+    UNRECOVERABLE_IF(nullptr == pOsPerformance);
+    init();
+}
+
+PerformanceImp::~PerformanceImp() {
+    if (pOsPerformance != nullptr) {
+        delete pOsPerformance;
+        pOsPerformance = nullptr;
+    }
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/performance_imp.h

@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "shared/source/helpers/non_copyable_or_moveable.h"
+
+#include "level_zero/sysman/source/performance/os_performance.h"
+#include "level_zero/sysman/source/performance/performance.h"
+#include <level_zero/zes_api.h>
+
+namespace L0 {
+namespace Sysman {
+
+class PerformanceImp : public Performance, NEO::NonCopyableOrMovableClass {
+  public:
+    ze_result_t performanceGetProperties(zes_perf_properties_t *pProperties) override;
+    ze_result_t performanceGetConfig(double *pFactor) override;
+    ze_result_t performanceSetConfig(double pFactor) override;
+
+    PerformanceImp() = delete;
+    PerformanceImp(OsSysman *pOsSysman, bool onSubdevice, uint32_t subDeviceId, zes_engine_type_flag_t domain);
+    ~PerformanceImp() override;
+    OsPerformance *pOsPerformance = nullptr;
+
+    void init();
+
+  private:
+    zes_perf_properties_t performanceProperties = {};
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/windows/CMakeLists.txt

@@ -0,0 +1,14 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+if(WIN32)
+  target_sources(${L0_STATIC_LIB_NAME}
+                 PRIVATE
+                 ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+                 ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.cpp
+                 ${CMAKE_CURRENT_SOURCE_DIR}/os_performance_imp.h
+  )
+endif()

level_zero/sysman/source/performance/windows/os_performance_imp.cpp

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/source/performance/windows/os_performance_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+ze_result_t WddmPerformanceImp::osPerformanceGetConfig(double *pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmPerformanceImp::osPerformanceSetConfig(double pFactor) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmPerformanceImp::osPerformanceGetProperties(zes_perf_properties_t &properties) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool WddmPerformanceImp::isPerformanceSupported(void) {
+    return false;
+}
+
+WddmPerformanceImp::WddmPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                                       zes_engine_type_flag_t domain) {}
+
+OsPerformance *OsPerformance::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                                     zes_engine_type_flag_t domain) {
+    WddmPerformanceImp *pWddmPerformanceImp = new WddmPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain);
+    return static_cast<OsPerformance *>(pWddmPerformanceImp);
+}
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/performance/windows/os_performance_imp.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/sysman/source/performance/os_performance.h"
+#include "level_zero/sysman/source/windows/os_sysman_imp.h"
+
+namespace L0 {
+namespace Sysman {
+
+class WddmPerformanceImp : public OsPerformance {
+  public:
+    ze_result_t osPerformanceGetProperties(zes_perf_properties_t &pProperties) override;
+    ze_result_t osPerformanceGetConfig(double *pFactor) override;
+    ze_result_t osPerformanceSetConfig(double pFactor) override;
+    bool isPerformanceSupported(void) override;
+    WddmPerformanceImp() = default;
+    WddmPerformanceImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId,
+                       zes_engine_type_flag_t domain);
+    ~WddmPerformanceImp() override = default;
+};
+
+} // namespace Sysman
+} // namespace L0

level_zero/sysman/source/sysman_const.h

@@ -15,6 +15,10 @@ constexpr uint32_t MbpsToBytesPerSecond = 125000;
 constexpr double milliVoltsFactor = 1000.0;
 constexpr uint32_t maxRasErrorCategoryCount = 7;
 
+constexpr double maxPerformanceFactor = 100;
+constexpr double halfOfMaxPerformanceFactor = 50;
+constexpr double minPerformanceFactor = 0;
+
 namespace L0 {
 namespace Sysman {
 struct SteadyClock {

level_zero/sysman/source/sysman_device.cpp

@@ -124,5 +124,10 @@ ze_result_t SysmanDevice::temperatureGet(zes_device_handle_t hDevice, uint32_t *
     return pSysmanDevice->temperatureGet(pCount, phTemperature);
 }
 
+ze_result_t SysmanDevice::performanceGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_perf_handle_t *phPerformance) {
+    auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice);
+    return pSysmanDevice->performanceGet(pCount, phPerformance);
+}
+
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/source/sysman_device.h

@@ -17,6 +17,7 @@
 #include "level_zero/sysman/source/frequency/frequency.h"
 #include "level_zero/sysman/source/global_operations/global_operations.h"
 #include "level_zero/sysman/source/memory/memory.h"
+#include "level_zero/sysman/source/performance/performance.h"
 #include "level_zero/sysman/source/power/power.h"
 #include "level_zero/sysman/source/ras/ras.h"
 #include "level_zero/sysman/source/scheduler/scheduler.h"
@@ -94,6 +95,9 @@ struct SysmanDevice : _ze_device_handle_t {
 
     static ze_result_t temperatureGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_temp_handle_t *phTemperature);
     virtual ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) = 0;
+
+    static ze_result_t performanceGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_perf_handle_t *phPerformance);
+    virtual ze_result_t performanceGet(uint32_t *pCount, zes_perf_handle_t *phPerformance) = 0;
 };
 
 } // namespace Sysman

level_zero/sysman/source/sysman_device_imp.cpp

@@ -34,6 +34,7 @@ SysmanDeviceImp::SysmanDeviceImp(NEO::ExecutionEnvironment *executionEnvironment
     pDiagnosticsHandleContext = new DiagnosticsHandleContext(pOsSysman);
     pGlobalOperations = new GlobalOperationsImp(pOsSysman);
     pStandbyHandleContext = new StandbyHandleContext(pOsSysman);
+    pPerformanceHandleContext = new PerformanceHandleContext(pOsSysman);
     pEcc = new EccImp(pOsSysman);
     pTempHandleContext = new TemperatureHandleContext(pOsSysman);
 }
@@ -50,6 +51,7 @@ SysmanDeviceImp::~SysmanDeviceImp() {
     freeResource(pMemoryHandleContext);
     freeResource(pFabricPortHandleContext);
     freeResource(pStandbyHandleContext);
+    freeResource(pPerformanceHandleContext);
     freeResource(pEcc);
     freeResource(pTempHandleContext);
     freeResource(pOsSysman);
@@ -144,5 +146,9 @@ ze_result_t SysmanDeviceImp::temperatureGet(uint32_t *pCount, zes_temp_handle_t
     return pTempHandleContext->temperatureGet(pCount, phTemperature);
 }
 
+ze_result_t SysmanDeviceImp::performanceGet(uint32_t *pCount, zes_perf_handle_t *phPerformance) {
+    return pPerformanceHandleContext->performanceGet(pCount, phPerformance);
+}
+
 } // namespace Sysman
 } // namespace L0

level_zero/sysman/source/sysman_device_imp.h

@@ -48,6 +48,7 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     DiagnosticsHandleContext *pDiagnosticsHandleContext = nullptr;
     FrequencyHandleContext *pFrequencyHandleContext = nullptr;
     StandbyHandleContext *pStandbyHandleContext = nullptr;
+    PerformanceHandleContext *pPerformanceHandleContext = nullptr;
     Ecc *pEcc = nullptr;
     TemperatureHandleContext *pTempHandleContext = nullptr;
 
@@ -71,6 +72,7 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     ze_result_t deviceGetEccState(zes_device_ecc_properties_t *pState) override;
     ze_result_t deviceSetEccState(const zes_device_ecc_desc_t *newState, zes_device_ecc_properties_t *pState) override;
     ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) override;
+    ze_result_t performanceGet(uint32_t *pCount, zes_perf_handle_t *phPerformance) override;
 
   private:
     NEO::ExecutionEnvironment *executionEnvironment = nullptr;

level_zero/sysman/test/unit_tests/sources/performance/CMakeLists.txt

@@ -0,0 +1,11 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+
+add_subdirectories()

level_zero/sysman/test/unit_tests/sources/performance/linux/CMakeLists.txt

@@ -0,0 +1,28 @@
+#
+# Copyright (C) 2023 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(L0_TESTS_SYSMAN_PERFORMANCE_LINUX
+    ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+)
+
+if(NEO_ENABLE_i915_PRELIM_DETECTION)
+  list(APPEND L0_TESTS_SYSMAN_PERFORMANCE_LINUX
+       ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_performance_prelim.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_performance_prelim.h
+  )
+else()
+  list(APPEND L0_TESTS_SYSMAN_PERFORMANCE_LINUX
+       ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_performance.cpp
+       ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_performance.h
+  )
+endif()
+
+if(UNIX)
+  target_sources(${TARGET_NAME}
+                 PRIVATE
+                 ${L0_TESTS_SYSMAN_PERFORMANCE_LINUX}
+  )
+endif()

level_zero/sysman/test/unit_tests/sources/performance/linux/mock_sysfs_performance.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/sysman/source/linux/fs_access.h"
+#include "level_zero/sysman/source/performance/linux/os_performance_imp.h"
+#include "level_zero/sysman/source/performance/performance.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+namespace L0 {
+namespace ult {
+} // namespace ult
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/performance/linux/mock_sysfs_performance_prelim.h

@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "level_zero/sysman/source/linux/fs_access.h"
+#include "level_zero/sysman/source/performance/linux/os_performance_imp_prelim.h"
+#include "level_zero/sysman/source/performance/performance.h"
+#include "level_zero/sysman/source/performance/performance_imp.h"
+
+namespace L0 {
+namespace ult {
+
+const std::string mediaFreqFactorSubDevice0("gt/gt0/media_freq_factor");
+const std::string mediaScaleSubDevice0("gt/gt0/media_freq_factor.scale");
+const std::string baseFreqFactorSubDevice0("gt/gt0/base_freq_factor");
+const std::string baseScaleSubDevice0("gt/gt0/base_freq_factor.scale");
+const std::string mediaFreqFactorSubDevice1("gt/gt1/media_freq_factor");
+const std::string mediaScaleSubDevice1("gt/gt1/media_freq_factor.scale");
+const std::string baseFreqFactorSubDevice1("gt/gt1/base_freq_factor");
+const std::string baseScaleSubDevice1("gt/gt1/base_freq_factor.scale");
+const std::string pwrBalance("sys_pwr_balance");
+
+struct MockPerformanceSysfsAccess : public L0::Sysman::SysfsAccess {
+    ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
+    ze_result_t mockCanReadResult = ZE_RESULT_SUCCESS;
+    ze_bool_t isComputeInvalid = false;
+    ze_bool_t isReturnUnknownFailure = false;
+    ze_bool_t returnNegativeFactor = false;
+    ze_bool_t isMediaBaseFailure = false;
+
+    ze_result_t getValWithMultiplierReturnOne(const std::string file, double &val) {
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0)) {
+            val = mockBaseVal1;
+        } else if ((file.compare(mediaFreqFactorSubDevice0) == 0) || (file.compare(mediaFreqFactorSubDevice1) == 0)) {
+            val = mockMediaVal1;
+        } else if ((file.compare(mediaScaleSubDevice0) == 0) || (file.compare(mediaScaleSubDevice1) == 0) || (file.compare(baseScaleSubDevice0) == 0) || (file.compare(baseScaleSubDevice1) == 0)) {
+            val = mockScale;
+        } else if (file.compare(pwrBalance) == 0) {
+            val = mockPwrBalance;
+        } else {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t getValUnknownFailure(const std::string file, double &val) {
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0)) {
+            val = 64.0;
+        } else if ((file.compare(mediaFreqFactorSubDevice0) == 0) || (file.compare(mediaFreqFactorSubDevice1) == 0)) {
+            val = 384.0;
+        } else if ((file.compare(mediaScaleSubDevice0) == 0) || (file.compare(mediaScaleSubDevice1) == 0) || (file.compare(baseScaleSubDevice0) == 0) || (file.compare(baseScaleSubDevice1) == 0)) {
+            val = mockScale;
+        } else if (file.compare(pwrBalance) == 0) {
+            val = 100.0;
+        } else {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t getValNegative(const std::string file, double &val) {
+        const std::list<std::string> nodeList = {baseFreqFactorSubDevice0, baseFreqFactorSubDevice1, mediaFreqFactorSubDevice0, mediaFreqFactorSubDevice1, mediaScaleSubDevice0, mediaScaleSubDevice1, baseScaleSubDevice0, baseScaleSubDevice1, pwrBalance};
+        for (const auto &node : nodeList) {
+            if ((file.compare(node) == 0)) {
+                val = -1.0;
+                return ZE_RESULT_SUCCESS;
+            }
+        }
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+    }
+
+    ze_result_t getValMediaBaseFailure(const std::string file, double &val) {
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0) || (file.compare(mediaFreqFactorSubDevice0) == 0) || (file.compare(mediaFreqFactorSubDevice1) == 0) || (file.compare(pwrBalance) == 0)) {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        if ((file.compare(mediaScaleSubDevice0) == 0) || (file.compare(mediaScaleSubDevice1) == 0) || (file.compare(baseScaleSubDevice0) == 0) || (file.compare(baseScaleSubDevice1) == 0)) {
+            val = mockScale;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t getValComputeInvalid(const std::string file, double &val) {
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0)) {
+            val = 1024.0;
+        } else if ((file.compare(mediaScaleSubDevice0) == 0) || (file.compare(mediaScaleSubDevice1) == 0) || (file.compare(baseScaleSubDevice0) == 0) || (file.compare(baseScaleSubDevice1) == 0)) {
+            val = mockScale;
+        } else {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t getValScaleFailure(const std::string file, double &val) {
+        if ((file.compare(mediaScaleSubDevice0) == 0) || (file.compare(mediaScaleSubDevice1) == 0) || (file.compare(baseScaleSubDevice0) == 0) || (file.compare(baseScaleSubDevice1) == 0)) {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t canRead(const std::string file) override {
+        if (mockCanReadResult != ZE_RESULT_SUCCESS) {
+            return mockCanReadResult;
+        }
+
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0) || (file.compare(mediaFreqFactorSubDevice0) == 0) || (file.compare(mediaFreqFactorSubDevice1) == 0) || (file.compare(pwrBalance) == 0)) {
+            return ZE_RESULT_SUCCESS;
+        }
+        return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
+    }
+
+    ze_result_t write(const std::string file, const double val) override {
+        if ((file.compare(baseFreqFactorSubDevice0) == 0) || (file.compare(baseFreqFactorSubDevice1) == 0)) {
+            mockBaseVal1 = val;
+        } else if ((file.compare(mediaFreqFactorSubDevice0) == 0) || (file.compare(mediaFreqFactorSubDevice1) == 0)) {
+            mockMediaVal1 = val;
+        } else if (file.compare(pwrBalance) == 0) {
+            mockPwrBalance = val;
+        } else {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_SUCCESS;
+    }
+
+    ze_result_t read(const std::string file, double &val) override {
+        if (mockReadResult != ZE_RESULT_SUCCESS) {
+            return mockReadResult;
+        }
+
+        if (isReturnUnknownFailure) {
+            return getValUnknownFailure(file, val);
+        } else if (isMediaBaseFailure) {
+            return getValMediaBaseFailure(file, val);
+        } else if (isComputeInvalid) {
+            return getValComputeInvalid(file, val);
+        } else if (returnNegativeFactor) {
+            return getValNegative(file, val);
+        } else {
+            return getValWithMultiplierReturnOne(file, val);
+        }
+    }
+
+    double mockBaseVal1 = 128.0;
+    double mockMediaVal1 = 256.0;
+    double mockMultiplierBase = 256.0;
+    double mockMultiplierMedia = 512.0;
+    double mockScale = 0.00390625;
+    double mockPwrBalance = 0.0;
+    MockPerformanceSysfsAccess() = default;
+};
+
+class PublicLinuxPerformanceImp : public L0::Sysman::LinuxPerformanceImp {
+  public:
+    PublicLinuxPerformanceImp(L0::Sysman::OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_engine_type_flag_t domain) : L0::Sysman::LinuxPerformanceImp(pOsSysman, onSubdevice, subdeviceId, domain) {}
+    using L0::Sysman::LinuxPerformanceImp::domain;
+    using L0::Sysman::LinuxPerformanceImp::pSysfsAccess;
+};
+
+} // namespace ult
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/performance/linux/test_zes_performance.cpp

@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
+#include "level_zero/sysman/test/unit_tests/sources/performance/linux/mock_sysfs_performance.h"
+
+namespace L0 {
+namespace ult {
+
+constexpr uint32_t mockHandleCount = 5;
+class ZesPerformanceFixture : public SysmanMultiDeviceFixture {
+  protected:
+    L0::Sysman::SysmanDevice *device = nullptr;
+    void SetUp() override {
+        SysmanMultiDeviceFixture::SetUp();
+        pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+        getPerfHandles(0);
+    }
+    void TearDown() override {
+        SysmanMultiDeviceFixture::TearDown();
+    }
+    std::vector<zes_perf_handle_t> getPerfHandles(uint32_t count) {
+        std::vector<zes_perf_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(ZesPerformanceFixture, GivenValidSysmanHandleWhenRetrievingPerfThenZeroHandlesInReturn) {
+    uint32_t count = 0;
+    ze_result_t result = zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockHandleCount);
+
+    uint32_t testcount = count + 1;
+    result = zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &testcount, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testcount, mockHandleCount);
+
+    count = 0;
+    std::vector<zes_perf_handle_t> handles(count, nullptr);
+    EXPECT_EQ(zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, mockHandleCount);
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidOsSysmanPointerWhenCreatingOsPerformanceThenValidhandleForOsPerformanceIsRetrieved) {
+
+    auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
+    uint32_t subdeviceId = 0;
+
+    for (subdeviceId = 0; subdeviceId < subDeviceCount; subdeviceId++) {
+        ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
+        L0::Sysman::Performance *pPerformance = new L0::Sysman::PerformanceImp(pOsSysman, onSubdevice, subdeviceId, ZES_ENGINE_TYPE_FLAG_MEDIA);
+        zes_perf_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, pPerformance->performanceGetProperties(&properties));
+        double factor = 0;
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPerformance->performanceGetConfig(&factor));
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPerformance->performanceSetConfig(factor));
+        EXPECT_FALSE(static_cast<L0::Sysman::PerformanceImp *>(pPerformance)->pOsPerformance->isPerformanceSupported());
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE,
+                  static_cast<L0::Sysman::PerformanceImp *>(pPerformance)->pOsPerformance->osPerformanceGetProperties(properties));
+        zes_perf_handle_t perfHandle = pPerformance->toPerformanceHandle();
+        EXPECT_EQ(pPerformance, L0::Sysman::Performance::fromHandle(perfHandle));
+        delete pPerformance;
+    }
+}
+
+} // namespace ult
+} // namespace L0

level_zero/sysman/test/unit_tests/sources/performance/linux/test_zes_performance_prelim.cpp

@@ -0,0 +1,318 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
+#include "level_zero/sysman/test/unit_tests/sources/performance/linux/mock_sysfs_performance_prelim.h"
+
+namespace L0 {
+namespace ult {
+
+constexpr uint32_t mockHandleCount = 5;
+constexpr double maxPerformanceFactor = 100;
+constexpr double halfOfMaxPerformanceFactor = 50;
+constexpr double minPerformanceFactor = 0;
+class ZesPerformanceFixture : public SysmanMultiDeviceFixture {
+  protected:
+    std::unique_ptr<MockPerformanceSysfsAccess> ptestSysfsAccess;
+    L0::Sysman::SysfsAccess *pOriginalSysfsAccess = nullptr;
+    L0::Sysman::SysmanDevice *device = nullptr;
+    void SetUp() override {
+        SysmanMultiDeviceFixture::SetUp();
+        device = pSysmanDevice;
+        ptestSysfsAccess = std::make_unique<MockPerformanceSysfsAccess>();
+        pOriginalSysfsAccess = pLinuxSysmanImp->pSysfsAccess;
+        pLinuxSysmanImp->pSysfsAccess = ptestSysfsAccess.get();
+        for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+            delete handle;
+        }
+        pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+        getPerfHandles(0);
+    }
+    void TearDown() override {
+        SysmanMultiDeviceFixture::TearDown();
+        pLinuxSysmanImp->pSysfsAccess = pOriginalSysfsAccess;
+    }
+
+    std::vector<zes_perf_handle_t> getPerfHandles(uint32_t count) {
+        std::vector<zes_perf_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(ZesPerformanceFixture, GivenValidSysmanHandleWhenRetrievingPerfThenValidHandlesReturned) {
+    uint32_t count = 0;
+    ze_result_t result = zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockHandleCount);
+
+    uint32_t testcount = count + 1;
+    result = zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &testcount, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testcount, mockHandleCount);
+
+    count = 0;
+    std::vector<zes_perf_handle_t> handles(count, nullptr);
+    EXPECT_EQ(zesDeviceEnumPerformanceFactorDomains(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, mockHandleCount);
+}
+
+TEST_F(ZesPerformanceFixture, GivenInAnyDomainTypeIfcanReadFailsWhenGettingPerfHandlesThenZeroHandlesAreRetrieved) {
+    ptestSysfsAccess->mockCanReadResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_MEDIA);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+    delete pLinuxPerformanceImp;
+
+    pLinuxPerformanceImp = nullptr;
+    pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_OTHER);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+    delete pLinuxPerformanceImp;
+
+    pLinuxPerformanceImp = nullptr;
+    pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 0, 0u, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenInAnyDomainTypeIfSysfsReadForMediaAndComputeScaleFailsWhileGettingPerfHandlesThenZeroHandlesAreRetrieved) {
+    ptestSysfsAccess->mockReadResult = ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS;
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_MEDIA);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+
+    delete pLinuxPerformanceImp;
+    pLinuxPerformanceImp = nullptr;
+    pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenInAnyDomainTypeIfMediaAndBaseFreqFactorSysfsNodesAreAbsentWhenGettingPerfHandlesThenZeroHandlesAreRetrieved) {
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+    ptestSysfsAccess->mockReadResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_MEDIA);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+
+    delete pLinuxPerformanceImp;
+    pLinuxPerformanceImp = nullptr;
+    pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenIncorrectConditionsWhenGettingPerfHandlesThenZeroHandlesAreRetrieved) {
+    // Check perf handle with incorrect domain type
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_DMA);
+    EXPECT_FALSE(pLinuxPerformanceImp->isPerformanceSupported());
+    delete pLinuxPerformanceImp;
+    pLinuxPerformanceImp = nullptr;
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandleWhenGettingPerformancePropertiesThenValidPropertiesReturned) {
+
+    auto subDeviceCount = pLinuxSysmanImp->getSubDeviceCount();
+    ze_bool_t onSubdevice = (subDeviceCount == 0) ? false : true;
+    uint32_t subdeviceId = 0;
+
+    auto handle = getPerfHandles(1u);
+    zes_perf_properties_t properties = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetProperties(handle[0], &properties));
+    EXPECT_TRUE(onSubdevice);
+    EXPECT_EQ(properties.engines, ZES_ENGINE_TYPE_FLAG_MEDIA);
+    EXPECT_EQ(properties.subdeviceId, subdeviceId);
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandleWhenGettingConfigThenSuccessIsReturned) {
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        double factor = 0;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &factor));
+        EXPECT_EQ(factor, 100);
+    }
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandlesWhenInvalidMultiplierValuesAreReturnedBySysfsInterfaceThenUnknownErrorIsReturned) {
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+    ptestSysfsAccess->isReturnUnknownFailure = true;
+    pSysmanDeviceImp->pPerformanceHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        double factor = 0;
+        EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zesPerformanceFactorGetConfig(handle, &factor));
+    }
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandlesWhenBaseAndMediaFreqFactorNodesAreAbsentThenUnsupportedFeatureIsReturned) {
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        delete handle;
+    }
+    pSysmanDeviceImp->pPerformanceHandleContext->handleList.clear();
+    ptestSysfsAccess->isMediaBaseFailure = true;
+    pSysmanDeviceImp->pPerformanceHandleContext->init(pLinuxSysmanImp->getSubDeviceCount());
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        double factor = 0;
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPerformanceFactorGetConfig(handle, &factor));
+    }
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandleWhenSettingConfigThenSuccessIsReturned) {
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        double setFactor = 0;
+        double getFactor;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+
+        setFactor = 100;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+        getFactor = 0;
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+        EXPECT_DOUBLE_EQ(std::round(getFactor), setFactor);
+    }
+}
+
+HWTEST2_F(ZesPerformanceFixture, GivenValidPerfHandleWhenSettingMediaConfigAndGettingMediaConfigForProductOtherThanPVCThenValidConfigIsReturned, IsNotPVC) {
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        zes_perf_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetProperties(handle, &properties));
+        if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
+            double setFactor = 49;
+            double getFactor = 0;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), halfOfMaxPerformanceFactor);
+
+            setFactor = 50;
+            getFactor = 0;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), halfOfMaxPerformanceFactor);
+
+            setFactor = 60;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), maxPerformanceFactor);
+
+            setFactor = 100;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), maxPerformanceFactor);
+
+            setFactor = 0;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), minPerformanceFactor);
+        }
+    }
+}
+
+HWTEST2_F(ZesPerformanceFixture, GivenValidPerfHandleWhenSettingMediaConfigAndGettingMediaConfigWhenProductFamilyIsPVCThenValidConfigIsReturned, IsPVC) {
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        zes_perf_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetProperties(handle, &properties));
+        if (properties.engines == ZES_ENGINE_TYPE_FLAG_MEDIA) {
+            double setFactor = 49;
+            double getFactor = 0;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), halfOfMaxPerformanceFactor);
+
+            setFactor = 60;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), maxPerformanceFactor);
+
+            setFactor = 100;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), maxPerformanceFactor);
+
+            setFactor = 0;
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(handle, setFactor));
+            EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(handle, &getFactor));
+            EXPECT_DOUBLE_EQ(std::round(getFactor), halfOfMaxPerformanceFactor);
+        }
+    }
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandlesButSysfsReadsFailAtDifferentBrancesWhenSettingPerfConfigThenPerfGetConfigFails) {
+    auto handles = getPerfHandles(mockHandleCount);
+    double factor = 0;
+
+    ptestSysfsAccess->isComputeInvalid = true;
+
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_COMPUTE);
+    EXPECT_TRUE(pLinuxPerformanceImp->isPerformanceSupported());
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pLinuxPerformanceImp->osPerformanceGetConfig(&factor));
+    delete pLinuxPerformanceImp;
+    pLinuxPerformanceImp = nullptr;
+    pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_DMA);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPerformanceImp->osPerformanceGetConfig(&factor));
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandleWhenGettingPerfConfigForOtherDomainAndSysfsReadReturnsInvalidValueThenPerfGetConfigFails) {
+    auto handles = getPerfHandles(mockHandleCount);
+    double factor = 0;
+
+    ptestSysfsAccess->returnNegativeFactor = true;
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 0, 0u, ZES_ENGINE_TYPE_FLAG_OTHER);
+    EXPECT_TRUE(pLinuxPerformanceImp->isPerformanceSupported());
+    EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pLinuxPerformanceImp->osPerformanceGetConfig(&factor));
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidPerfHandlesButSysfsReadsFailAtDifferentBrancesWhenSettingPerfConfigThenPerfSetConfigFails) {
+    auto handles = getPerfHandles(mockHandleCount);
+    for (const auto &handle : handles) {
+        double setFactor = 110;
+        EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zesPerformanceFactorSetConfig(handle, setFactor));
+
+        setFactor = -10;
+        EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zesPerformanceFactorSetConfig(handle, setFactor));
+    }
+
+    double factor = 50;
+    // Set perf Config with incorrect domain type
+    PublicLinuxPerformanceImp *pLinuxPerformanceImp = new PublicLinuxPerformanceImp(pOsSysman, 1, 0u, ZES_ENGINE_TYPE_FLAG_DMA);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxPerformanceImp->osPerformanceSetConfig(factor));
+    delete pLinuxPerformanceImp;
+}
+
+TEST_F(ZesPerformanceFixture, GivenValidOfjectsOfClassPerformanceImpAndPerformanceHandleContextThenDuringObjectReleaseCheckDestructorBranches) {
+    for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {
+        auto pPerformanceImp = static_cast<L0::Sysman::PerformanceImp *>(handle);
+        delete pPerformanceImp->pOsPerformance;
+        pPerformanceImp->pOsPerformance = nullptr;
+        delete handle;
+        handle = nullptr;
+    }
+}
+
+} // namespace ult
+} // namespace L0

level_zero/tools/source/sysman/performance/performance.h

@@ -6,16 +6,13 @@
  */
 
 #pragma once
+#include "level_zero/api/sysman/zes_handles_struct.h"
 #include "level_zero/core/source/device/device.h"
 #include <level_zero/zes_api.h>
 
 #include <mutex>
 #include <vector>
 
-struct _zes_perf_handle_t {
-    virtual ~_zes_perf_handle_t() = default;
-};
-
 namespace L0 {
 
 struct OsSysman;

level_zero/tools/test/black_box_tests/zello_sysman.cpp

@@ -1332,10 +1332,14 @@ bool checkpFactorArguments(std::vector<ze_device_handle_t> &devices, std::vector
     if (deviceIndex >= devices.size()) {
         return false;
     }
-    uint32_t count = 0;
-    VALIDATECALL(zeDeviceGetSubDevices(devices[deviceIndex], &count, nullptr));
+
+    uint32_t subDeviceCount = 0;
+    zes_device_properties_t properties = {};
+    VALIDATECALL(zesDeviceGetProperties(devices[deviceIndex], &properties));
+    subDeviceCount = properties.numSubdevices;
+
     uint32_t subDeviceIndex = static_cast<uint32_t>(std::stoi(buf[2]));
-    if (count > 0 && subDeviceIndex >= count) {
+    if (subDeviceCount > 0 && subDeviceIndex >= subDeviceCount) {
         return false;
     }
     zes_engine_type_flags_t engineTypeFlag = getEngineFlagType(buf[3]);