mirror of
https://github.com/intel/compute-runtime.git
synced 2026-01-07 12:42:54 +08:00
Adding Frequency Support for Windows in Level 0 Sysman
Change-Id: I8dbf67b0a6f88379a3da304e01a8f102e2027dd1
This commit is contained in:
Daniel Enriquez
committed by
sys_ocldev
sys_ocldev
parent
b7852303e8
commit
f0907361ff
@@ -20,16 +20,17 @@ FrequencyHandleContext::~FrequencyHandleContext() {
|
||||
}
|
||||
}
|
||||
|
||||
void FrequencyHandleContext::createHandle(ze_device_handle_t deviceHandle, uint16_t frequencyDomain) {
|
||||
void FrequencyHandleContext::createHandle(ze_device_handle_t deviceHandle, zes_freq_domain_t frequencyDomain) {
|
||||
Frequency *pFrequency = new FrequencyImp(pOsSysman, deviceHandle, frequencyDomain);
|
||||
handleList.push_back(pFrequency);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyHandleContext::init(std::vector<ze_device_handle_t> deviceHandles) {
|
||||
for (auto deviceHandle : deviceHandles) {
|
||||
auto totalDomains = OsFrequency::getHardwareBlockCount(deviceHandle);
|
||||
for (uint16_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {
|
||||
createHandle(deviceHandle, frequencyDomain);
|
||||
auto totalDomains = OsFrequency::getNumberOfFreqDoainsSupported(pOsSysman);
|
||||
UNRECOVERABLE_IF(totalDomains > 2);
|
||||
for (uint32_t frequencyDomain = 0; frequencyDomain < totalDomains; frequencyDomain++) {
|
||||
createHandle(deviceHandle, static_cast<zes_freq_domain_t>(frequencyDomain));
|
||||
}
|
||||
}
|
||||
return ZE_RESULT_SUCCESS;
|
||||
|
||||
@@ -17,6 +17,8 @@ struct _zes_freq_handle_t {
|
||||
|
||||
namespace L0 {
|
||||
|
||||
constexpr double unsupportedProperty = -1.0;
|
||||
|
||||
struct OsSysman;
|
||||
|
||||
class Frequency : _zes_freq_handle_t {
|
||||
@@ -30,6 +32,19 @@ class Frequency : _zes_freq_handle_t {
|
||||
virtual ze_result_t frequencyGetState(zes_freq_state_t *pState) = 0;
|
||||
virtual ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) = 0;
|
||||
|
||||
// Overclocking
|
||||
virtual ze_result_t frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) = 0;
|
||||
virtual ze_result_t frequencyOcGetFrequencyTarget(double *pCurrentOcfrequency) = 0;
|
||||
virtual ze_result_t frequencyOcSetFrequencyTarget(double currentOcfrequency) = 0;
|
||||
virtual ze_result_t frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) = 0;
|
||||
virtual ze_result_t frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) = 0;
|
||||
virtual ze_result_t frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) = 0;
|
||||
virtual ze_result_t frequencyOcSetMode(zes_oc_mode_t currentOcMode) = 0;
|
||||
virtual ze_result_t frequencyOcGetIccMax(double *pOcIccMax) = 0;
|
||||
virtual ze_result_t frequencyOcSetIccMax(double ocIccMax) = 0;
|
||||
virtual ze_result_t frequencyOcGeTjMax(double *pOcTjMax) = 0;
|
||||
virtual ze_result_t frequencyOcSetTjMax(double ocTjMax) = 0;
|
||||
|
||||
static Frequency *fromHandle(zes_freq_handle_t handle) {
|
||||
return static_cast<Frequency *>(handle);
|
||||
}
|
||||
@@ -48,7 +63,7 @@ struct FrequencyHandleContext {
|
||||
std::vector<Frequency *> handleList = {};
|
||||
|
||||
private:
|
||||
void createHandle(ze_device_handle_t deviceHandle, uint16_t frequencyDomain);
|
||||
void createHandle(ze_device_handle_t deviceHandle, zes_freq_domain_t frequencyDomain);
|
||||
};
|
||||
|
||||
} // namespace L0
|
||||
|
||||
@@ -65,8 +65,51 @@ ze_result_t FrequencyImp::frequencyGetThrottleTime(zes_freq_throttle_time_t *pTh
|
||||
return pOsFrequency->osFrequencyGetThrottleTime(pThrottleTime);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
|
||||
return pOsFrequency->getOcCapabilities(pOcCapabilities);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGetFrequencyTarget(double *pCurrentOcFrequency) {
|
||||
return pOsFrequency->getOcFrequencyTarget(pCurrentOcFrequency);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcSetFrequencyTarget(double currentOcFrequency) {
|
||||
return pOsFrequency->setOcFrequencyTarget(currentOcFrequency);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
|
||||
return pOsFrequency->getOcVoltageTarget(pCurrentVoltageTarget, pCurrentVoltageOffset);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
|
||||
return pOsFrequency->setOcVoltageTarget(currentVoltageTarget, currentVoltageOffset);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) {
|
||||
return pOsFrequency->getOcMode(pCurrentOcMode);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcSetMode(zes_oc_mode_t currentOcMode) {
|
||||
return pOsFrequency->setOcMode(currentOcMode);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGetIccMax(double *pOcIccMax) {
|
||||
return pOsFrequency->getOcIccMax(pOcIccMax);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcSetIccMax(double ocIccMax) {
|
||||
return pOsFrequency->setOcIccMax(ocIccMax);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcGeTjMax(double *pOcTjMax) {
|
||||
return pOsFrequency->getOcTjMax(pOcTjMax);
|
||||
}
|
||||
|
||||
ze_result_t FrequencyImp::frequencyOcSetTjMax(double ocTjMax) {
|
||||
return pOsFrequency->setOcTjMax(ocTjMax);
|
||||
}
|
||||
|
||||
void FrequencyImp::init() {
|
||||
zesFrequencyProperties.type = static_cast<zes_freq_domain_t>(frequencyDomain);
|
||||
pOsFrequency->osFrequencyGetProperties(zesFrequencyProperties);
|
||||
double freqRange = zesFrequencyProperties.max - zesFrequencyProperties.min;
|
||||
numClocks = static_cast<uint32_t>(round(freqRange / step)) + 1;
|
||||
@@ -76,10 +119,10 @@ void FrequencyImp::init() {
|
||||
}
|
||||
}
|
||||
|
||||
FrequencyImp::FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, uint16_t frequencyDomain) : deviceHandle(handle), frequencyDomain(frequencyDomain) {
|
||||
FrequencyImp::FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, zes_freq_domain_t frequencyDomainNumber) : deviceHandle(handle) {
|
||||
ze_device_properties_t deviceProperties = {};
|
||||
Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
|
||||
pOsFrequency = OsFrequency::create(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, deviceProperties.subdeviceId);
|
||||
pOsFrequency = OsFrequency::create(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE, deviceProperties.subdeviceId, frequencyDomainNumber);
|
||||
UNRECOVERABLE_IF(nullptr == pOsFrequency);
|
||||
|
||||
init();
|
||||
|
||||
@@ -24,8 +24,21 @@ class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
|
||||
ze_result_t frequencyGetState(zes_freq_state_t *pState) override;
|
||||
ze_result_t frequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
|
||||
|
||||
// Overclocking
|
||||
ze_result_t frequencyOcGetCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
|
||||
ze_result_t frequencyOcGetFrequencyTarget(double *pCurrentOcFrequency) override;
|
||||
ze_result_t frequencyOcSetFrequencyTarget(double currentOcFrequency) override;
|
||||
ze_result_t frequencyOcGetVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
|
||||
ze_result_t frequencyOcSetVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
|
||||
ze_result_t frequencyOcGetMode(zes_oc_mode_t *pCurrentOcMode) override;
|
||||
ze_result_t frequencyOcSetMode(zes_oc_mode_t currentOcMode) override;
|
||||
ze_result_t frequencyOcGetIccMax(double *pOcIccMax) override;
|
||||
ze_result_t frequencyOcSetIccMax(double ocIccMax) override;
|
||||
ze_result_t frequencyOcGeTjMax(double *pOcTjMax) override;
|
||||
ze_result_t frequencyOcSetTjMax(double ocTjMax) override;
|
||||
|
||||
FrequencyImp() = default;
|
||||
FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, uint16_t frequencyDomain);
|
||||
FrequencyImp(OsSysman *pOsSysman, ze_device_handle_t handle, zes_freq_domain_t frequencyDomainNumber);
|
||||
~FrequencyImp() override;
|
||||
OsFrequency *pOsFrequency = nullptr;
|
||||
void init();
|
||||
@@ -37,7 +50,6 @@ class FrequencyImp : public Frequency, NEO::NonCopyableOrMovableClass {
|
||||
double *pClocks = nullptr;
|
||||
uint32_t numClocks = 0;
|
||||
ze_device_handle_t deviceHandle = nullptr;
|
||||
uint16_t frequencyDomain = 0;
|
||||
};
|
||||
|
||||
} // namespace L0
|
||||
|
||||
@@ -16,6 +16,7 @@ const bool LinuxFrequencyImp::canControl = true; // canControl is true on i915 (
|
||||
ze_result_t LinuxFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
|
||||
properties.pNext = nullptr;
|
||||
properties.canControl = canControl;
|
||||
properties.type = frequencyDomainNumber;
|
||||
ze_result_t result1 = getMinVal(properties.min);
|
||||
ze_result_t result2 = getMaxVal(properties.max);
|
||||
// If can't figure out the valid range, then can't control it.
|
||||
@@ -96,6 +97,50 @@ ze_result_t LinuxFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcIccMax(double *pOcIccMax) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::setOcIccMax(double ocIccMax) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getOcTjMax(double *pOcTjMax) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::setOcTjMax(double ocTjMax) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
ze_result_t LinuxFrequencyImp::getMin(double &min) {
|
||||
double intval;
|
||||
|
||||
@@ -241,18 +286,18 @@ void LinuxFrequencyImp::init() {
|
||||
minValFreqFile = "gt_RPn_freq_mhz";
|
||||
}
|
||||
|
||||
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) : isSubdevice(onSubdevice), subdeviceId(subdeviceId) {
|
||||
LinuxFrequencyImp::LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) : isSubdevice(onSubdevice), subdeviceId(subdeviceId), frequencyDomainNumber(frequencyDomainNumber) {
|
||||
LinuxSysmanImp *pLinuxSysmanImp = static_cast<LinuxSysmanImp *>(pOsSysman);
|
||||
pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
|
||||
init();
|
||||
}
|
||||
|
||||
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
|
||||
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId);
|
||||
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
|
||||
LinuxFrequencyImp *pLinuxFrequencyImp = new LinuxFrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
|
||||
return static_cast<OsFrequency *>(pLinuxFrequencyImp);
|
||||
}
|
||||
|
||||
uint16_t OsFrequency::getHardwareBlockCount(ze_device_handle_t handle) {
|
||||
uint16_t OsFrequency::getNumberOfFreqDoainsSupported(OsSysman *pOsSysman) {
|
||||
return 1; // hardcode for now to support only ZES_FREQ_DOMAIN_GPU
|
||||
}
|
||||
|
||||
|
||||
@@ -21,8 +21,19 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
|
||||
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
|
||||
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
|
||||
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
|
||||
ze_result_t getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
|
||||
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
|
||||
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
|
||||
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
|
||||
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
|
||||
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
|
||||
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
|
||||
ze_result_t getOcIccMax(double *pOcIccMax) override;
|
||||
ze_result_t setOcIccMax(double ocIccMax) override;
|
||||
ze_result_t getOcTjMax(double *pOcTjMax) override;
|
||||
ze_result_t setOcTjMax(double ocTjMax) override;
|
||||
LinuxFrequencyImp() = default;
|
||||
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
|
||||
LinuxFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber);
|
||||
~LinuxFrequencyImp() override = default;
|
||||
|
||||
protected:
|
||||
@@ -50,6 +61,7 @@ class LinuxFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
|
||||
static const bool canControl;
|
||||
bool isSubdevice = false;
|
||||
uint32_t subdeviceId = 0;
|
||||
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
|
||||
void init();
|
||||
};
|
||||
|
||||
|
||||
@@ -18,9 +18,19 @@ class OsFrequency {
|
||||
virtual ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) = 0;
|
||||
virtual ze_result_t osFrequencyGetState(zes_freq_state_t *pState) = 0;
|
||||
virtual ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) = 0;
|
||||
|
||||
static OsFrequency *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId);
|
||||
static uint16_t getHardwareBlockCount(ze_device_handle_t handle);
|
||||
virtual ze_result_t getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) = 0;
|
||||
virtual ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) = 0;
|
||||
virtual ze_result_t setOcFrequencyTarget(double currentOcFrequency) = 0;
|
||||
virtual ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) = 0;
|
||||
virtual ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) = 0;
|
||||
virtual ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) = 0;
|
||||
virtual ze_result_t setOcMode(zes_oc_mode_t currentOcMode) = 0;
|
||||
virtual ze_result_t getOcIccMax(double *pOcIccMax) = 0;
|
||||
virtual ze_result_t setOcIccMax(double ocIccMax) = 0;
|
||||
virtual ze_result_t getOcTjMax(double *pOcTjMax) = 0;
|
||||
virtual ze_result_t setOcTjMax(double ocTjMax) = 0;
|
||||
static OsFrequency *create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type);
|
||||
static uint16_t getNumberOfFreqDoainsSupported(OsSysman *pOsSysman);
|
||||
virtual ~OsFrequency() {}
|
||||
};
|
||||
|
||||
|
||||
@@ -1,11 +1,11 @@
|
||||
#
|
||||
# Copyright (C) 2019-2020 Intel Corporation
|
||||
# Copyright (C) 2020 Intel Corporation
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
#
|
||||
|
||||
set(L0_SRCS_TOOLS_SYSMAN_FREQUENCY_WINDOWS
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.h
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/os_frequency_imp.cpp
|
||||
)
|
||||
|
||||
|
||||
@@ -5,46 +5,656 @@
|
||||
*
|
||||
*/
|
||||
|
||||
#include "level_zero/tools/source/sysman/frequency/os_frequency.h"
|
||||
#include "level_zero/tools/source/sysman/frequency/windows/os_frequency_imp.h"
|
||||
|
||||
namespace L0 {
|
||||
|
||||
class WddmFrequencyImp : public OsFrequency {
|
||||
public:
|
||||
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
|
||||
ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) override;
|
||||
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
|
||||
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
|
||||
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
|
||||
};
|
||||
|
||||
ze_result_t WddmFrequencyImp::osFrequencyGetProperties(zes_freq_properties_t &properties) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
readOverclockingInfo();
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::FrequencyThrottledEventSupported;
|
||||
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
|
||||
|
||||
properties.isThrottleEventSupported = false;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
properties.isThrottleEventSupported = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::FrequencyRangeMinDefault;
|
||||
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
|
||||
|
||||
properties.min = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
value = 0;
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
properties.min = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::FrequencyRangeMaxDefault;
|
||||
request.paramInfo = static_cast<uint32_t>(frequencyDomainNumber);
|
||||
|
||||
properties.max = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
value = 0;
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
properties.max = static_cast<double>(value);
|
||||
}
|
||||
|
||||
properties.onSubdevice = false;
|
||||
properties.subdeviceId = 0;
|
||||
properties.type = frequencyDomainNumber;
|
||||
properties.canControl = canControl();
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::osFrequencyGetRange(zes_freq_range_t *pLimits) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
return getRange(&pLimits->min, &pLimits->max);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::osFrequencySetRange(const zes_freq_range_t *pLimits) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
return setRange(pLimits->min, pLimits->max);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::osFrequencyGetState(zes_freq_state_t *pState) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentRequestedFrequency;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
pState->request = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
pState->request = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentTdpFrequency;
|
||||
|
||||
pState->tdp = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
pState->tdp = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentResolvedFrequency;
|
||||
|
||||
pState->actual = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
pState->actual = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentEfficientFrequency;
|
||||
|
||||
pState->efficient = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
pState->efficient = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltage;
|
||||
|
||||
pState->currentVoltage = unsupportedProperty;
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
pState->currentVoltage = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentThrottleReasons;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
KmdThrottleReasons value = {0};
|
||||
pState->throttleReasons = {0};
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
|
||||
if (value.powerlimit1) {
|
||||
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_AVE_PWR_CAP;
|
||||
}
|
||||
if (value.powerlimit2) {
|
||||
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_BURST_PWR_CAP;
|
||||
}
|
||||
if (value.powerlimit4) {
|
||||
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_CURRENT_LIMIT;
|
||||
}
|
||||
if (value.thermal) {
|
||||
pState->throttleReasons |= ZES_FREQ_THROTTLE_REASON_FLAG_THERMAL_LIMIT;
|
||||
}
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) {
|
||||
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
|
||||
}
|
||||
|
||||
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId) {
|
||||
WddmFrequencyImp *pWddmFrequencyImp = new WddmFrequencyImp();
|
||||
bool WddmFrequencyImp::canControl() {
|
||||
double minF = 0.0, maxF = 0.0;
|
||||
if (getRange(&minF, &maxF) != ZE_RESULT_SUCCESS) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return (setRange(minF, maxF) == ZE_RESULT_SUCCESS);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) {
|
||||
*pOcCapabilities = ocCapabilities;
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcFrequencyTarget(double *pCurrentOcFrequency) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*pCurrentOcFrequency = currentFrequencyTarget = static_cast<double>(value);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setOcFrequencyTarget(double currentOcFrequency) {
|
||||
if (currentFrequencyTarget != currentOcFrequency) {
|
||||
currentFrequencyTarget = currentOcFrequency;
|
||||
return applyOcSettings();
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*pCurrentVoltageTarget = currentVoltageTarget = static_cast<double>(value);
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*pCurrentVoltageOffset = currentVoltageOffset = static_cast<double>(value);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) {
|
||||
if (this->currentVoltageTarget != currentVoltageTarget || this->currentVoltageOffset != currentVoltageOffset) {
|
||||
this->currentVoltageTarget = currentVoltageTarget;
|
||||
this->currentVoltageOffset = currentVoltageOffset;
|
||||
return applyOcSettings();
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcMode(zes_oc_mode_t *pCurrentOcMode) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFixedMode;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentFixedMode = value ? ZES_OC_MODE_FIXED : ZES_OC_MODE_OFF;
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentVoltageMode = value ? ZES_OC_MODE_OVERRIDE : ZES_OC_MODE_INTERPOLATIVE;
|
||||
|
||||
if (currentFixedMode == ZES_OC_MODE_FIXED) {
|
||||
currentOcMode = ZES_OC_MODE_FIXED;
|
||||
} else {
|
||||
currentOcMode = currentVoltageMode;
|
||||
}
|
||||
|
||||
*pCurrentOcMode = currentOcMode;
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setOcMode(zes_oc_mode_t currentOcMode) {
|
||||
if (currentOcMode == ZES_OC_MODE_OFF) {
|
||||
this->currentFrequencyTarget = ocCapabilities.maxFactoryDefaultFrequency;
|
||||
this->currentVoltageTarget = ocCapabilities.maxFactoryDefaultVoltage;
|
||||
this->currentVoltageOffset = 0;
|
||||
this->currentFixedMode = ZES_OC_MODE_OFF;
|
||||
this->currentVoltageMode = ZES_OC_MODE_INTERPOLATIVE;
|
||||
this->currentOcMode = ZES_OC_MODE_OFF;
|
||||
return applyOcSettings();
|
||||
}
|
||||
|
||||
if (currentOcMode == ZES_OC_MODE_FIXED) {
|
||||
this->currentOcMode = ZES_OC_MODE_FIXED;
|
||||
this->currentFixedMode = ZES_OC_MODE_FIXED;
|
||||
this->currentVoltageMode = ZES_OC_MODE_OVERRIDE;
|
||||
return applyOcSettings();
|
||||
}
|
||||
|
||||
if (currentOcMode == ZES_OC_MODE_INTERPOLATIVE || currentOcMode == ZES_OC_MODE_OVERRIDE) {
|
||||
this->currentVoltageMode = currentOcMode;
|
||||
this->currentFixedMode = ZES_OC_MODE_OFF;
|
||||
this->currentOcMode = currentOcMode;
|
||||
return applyOcSettings();
|
||||
}
|
||||
|
||||
return ZE_RESULT_SUCCESS;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcIccMax(double *pOcIccMax) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*pOcIccMax = static_cast<double>(value);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setOcIccMax(double ocIccMax) {
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Set;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
request.dataSize = sizeof(uint32_t);
|
||||
|
||||
value = static_cast<uint32_t>(ocIccMax);
|
||||
memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
|
||||
|
||||
return pKmdSysManager->requestSingle(request, response);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getOcTjMax(double *pOcTjMax) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentTjMax;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*pOcTjMax = static_cast<double>(value);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setOcTjMax(double ocTjMax) {
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Set;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
request.dataSize = sizeof(uint32_t);
|
||||
|
||||
value = static_cast<uint32_t>(ocTjMax);
|
||||
memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
|
||||
|
||||
return pKmdSysManager->requestSingle(request, response);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::setRange(double min, double max) {
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Set;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyRange;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
request.dataSize = 2 * sizeof(uint32_t);
|
||||
|
||||
value = static_cast<uint32_t>(min);
|
||||
memcpy_s(request.dataBuffer, sizeof(uint32_t), &value, sizeof(uint32_t));
|
||||
value = static_cast<uint32_t>(max);
|
||||
memcpy_s((request.dataBuffer + sizeof(uint32_t)), sizeof(uint32_t), &value, sizeof(uint32_t));
|
||||
|
||||
return pKmdSysManager->requestSingle(request, response);
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::getRange(double *min, double *max) {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyRange;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
uint32_t value = 0;
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
*min = static_cast<double>(value);
|
||||
memcpy_s(&value, sizeof(uint32_t), (response.dataBuffer + sizeof(uint32_t)), sizeof(uint32_t));
|
||||
*max = static_cast<double>(value);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
ze_result_t WddmFrequencyImp::applyOcSettings() {
|
||||
ze_result_t status = ZE_RESULT_SUCCESS;
|
||||
int32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Set;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFixedMode;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
request.dataSize = sizeof(int32_t);
|
||||
|
||||
value = (currentFixedMode == ZES_OC_MODE_FIXED) ? 1 : 0;
|
||||
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
|
||||
|
||||
value = (currentVoltageMode == ZES_OC_MODE_OVERRIDE) ? 1 : 0;
|
||||
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
|
||||
|
||||
value = static_cast<int32_t>(currentVoltageOffset);
|
||||
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
|
||||
|
||||
value = static_cast<int32_t>(currentVoltageTarget);
|
||||
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
|
||||
|
||||
status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return status;
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
|
||||
|
||||
value = static_cast<int32_t>(currentFrequencyTarget);
|
||||
memcpy_s(request.dataBuffer, sizeof(int32_t), &value, sizeof(int32_t));
|
||||
|
||||
return pKmdSysManager->requestSingle(request, response);
|
||||
}
|
||||
|
||||
void WddmFrequencyImp::readOverclockingInfo() {
|
||||
uint32_t value = 0;
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::ExtendedOcSupported;
|
||||
request.paramInfo = static_cast<uint32_t>(this->frequencyDomainNumber);
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isExtendedModeSupported = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::FixedModeSupported;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isFixedModeSupported = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::HighVoltageModeSupported;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isHighVoltModeCapable = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::HighVoltageEnabled;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isHighVoltModeEnabled = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentIccMax;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isIccMaxSupported = static_cast<ze_bool_t>(value > 0);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::FrequencyOcSupported;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isOcSupported = static_cast<ze_bool_t>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentTjMax;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.isTjMaxSupported = static_cast<ze_bool_t>(value > 0);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcFrequencyDefault;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.maxFactoryDefaultFrequency = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::MaxNonOcVoltageDefault;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.maxFactoryDefaultVoltage = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::MaxOcFrequencyDefault;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.maxOcFrequency = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::MaxOcVoltageDefault;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
ocCapabilities.maxOcVoltage = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFixedMode;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentFixedMode = value ? ZES_OC_MODE_FIXED : ZES_OC_MODE_OFF;
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentFrequencyTarget;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentFrequencyTarget = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageTarget;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentVoltageTarget = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageOffset;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentVoltageOffset = static_cast<double>(value);
|
||||
}
|
||||
|
||||
request.requestId = KmdSysman::Requests::Frequency::CurrentVoltageMode;
|
||||
|
||||
if (pKmdSysManager->requestSingle(request, response) == ZE_RESULT_SUCCESS) {
|
||||
memcpy_s(&value, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
currentVoltageMode = value ? ZES_OC_MODE_OVERRIDE : ZES_OC_MODE_INTERPOLATIVE;
|
||||
}
|
||||
|
||||
if (currentFrequencyTarget == 0.0 || currentVoltageTarget == 0.0) {
|
||||
if (currentFrequencyTarget == 0.0) {
|
||||
currentFrequencyTarget = ocCapabilities.maxFactoryDefaultFrequency;
|
||||
}
|
||||
|
||||
if (currentVoltageTarget == 0.0) {
|
||||
currentVoltageTarget = ocCapabilities.maxFactoryDefaultVoltage;
|
||||
}
|
||||
}
|
||||
|
||||
if (currentFixedMode == ZES_OC_MODE_FIXED) {
|
||||
currentOcMode = ZES_OC_MODE_FIXED;
|
||||
} else {
|
||||
currentOcMode = currentVoltageMode;
|
||||
}
|
||||
}
|
||||
|
||||
WddmFrequencyImp::WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
|
||||
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
|
||||
this->frequencyDomainNumber = frequencyDomainNumber;
|
||||
pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
|
||||
}
|
||||
|
||||
OsFrequency *OsFrequency::create(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t frequencyDomainNumber) {
|
||||
WddmFrequencyImp *pWddmFrequencyImp = new WddmFrequencyImp(pOsSysman, onSubdevice, subdeviceId, frequencyDomainNumber);
|
||||
return static_cast<OsFrequency *>(pWddmFrequencyImp);
|
||||
}
|
||||
|
||||
uint16_t OsFrequency::getHardwareBlockCount(ze_device_handle_t handle) {
|
||||
return 1;
|
||||
uint16_t OsFrequency::getNumberOfFreqDoainsSupported(OsSysman *pOsSysman) {
|
||||
WddmSysmanImp *pWddmSysmanImp = static_cast<WddmSysmanImp *>(pOsSysman);
|
||||
KmdSysManager *pKmdSysManager = &pWddmSysmanImp->getKmdSysManager();
|
||||
|
||||
KmdSysman::RequestProperty request;
|
||||
KmdSysman::ResponseProperty response;
|
||||
|
||||
request.commandId = KmdSysman::Command::Get;
|
||||
request.componentId = KmdSysman::Component::FrequencyComponent;
|
||||
request.requestId = KmdSysman::Requests::Frequency::NumFrequencyDomains;
|
||||
|
||||
ze_result_t status = pKmdSysManager->requestSingle(request, response);
|
||||
|
||||
if (status != ZE_RESULT_SUCCESS) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
uint32_t maxNumEnginesSupported = 0;
|
||||
memcpy_s(&maxNumEnginesSupported, sizeof(uint32_t), response.dataBuffer, sizeof(uint32_t));
|
||||
|
||||
return static_cast<uint16_t>(maxNumEnginesSupported);
|
||||
}
|
||||
|
||||
} // namespace L0
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
/*
|
||||
* Copyright (C) 2020 Intel Corporation
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include "shared/source/helpers/non_copyable_or_moveable.h"
|
||||
|
||||
#include "sysman/frequency/os_frequency.h"
|
||||
#include "sysman/windows/os_sysman_imp.h"
|
||||
|
||||
#define KMD_BIT_RANGE(endbit, startbit) ((endbit) - (startbit) + 1)
|
||||
|
||||
namespace L0 {
|
||||
|
||||
struct KmdThrottleReasons {
|
||||
union {
|
||||
uint32_t bitfield;
|
||||
struct {
|
||||
uint32_t reserved1 : KMD_BIT_RANGE(16, 0);
|
||||
uint32_t thermal : KMD_BIT_RANGE(17, 17);
|
||||
uint32_t reserved2 : KMD_BIT_RANGE(23, 18);
|
||||
uint32_t powerlimit4 : KMD_BIT_RANGE(24, 24);
|
||||
uint32_t reserved3 : KMD_BIT_RANGE(25, 25);
|
||||
uint32_t powerlimit1 : KMD_BIT_RANGE(26, 26);
|
||||
uint32_t powerlimit2 : KMD_BIT_RANGE(27, 27);
|
||||
uint32_t reserved4 : KMD_BIT_RANGE(31, 28);
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
class KmdSysManager;
|
||||
class WddmFrequencyImp : public OsFrequency, NEO::NonCopyableOrMovableClass {
|
||||
public:
|
||||
ze_result_t osFrequencyGetProperties(zes_freq_properties_t &properties) override;
|
||||
ze_result_t osFrequencyGetRange(zes_freq_range_t *pLimits) override;
|
||||
ze_result_t osFrequencySetRange(const zes_freq_range_t *pLimits) override;
|
||||
ze_result_t osFrequencyGetState(zes_freq_state_t *pState) override;
|
||||
ze_result_t osFrequencyGetThrottleTime(zes_freq_throttle_time_t *pThrottleTime) override;
|
||||
|
||||
ze_result_t getOcCapabilities(zes_oc_capabilities_t *pOcCapabilities) override;
|
||||
ze_result_t getOcFrequencyTarget(double *pCurrentOcFrequency) override;
|
||||
ze_result_t setOcFrequencyTarget(double currentOcFrequency) override;
|
||||
ze_result_t getOcVoltageTarget(double *pCurrentVoltageTarget, double *pCurrentVoltageOffset) override;
|
||||
ze_result_t setOcVoltageTarget(double currentVoltageTarget, double currentVoltageOffset) override;
|
||||
ze_result_t getOcMode(zes_oc_mode_t *pCurrentOcMode) override;
|
||||
ze_result_t setOcMode(zes_oc_mode_t currentOcMode) override;
|
||||
ze_result_t getOcIccMax(double *pOcIccMax) override;
|
||||
ze_result_t setOcIccMax(double ocIccMax) override;
|
||||
ze_result_t getOcTjMax(double *pOcTjMax) override;
|
||||
ze_result_t setOcTjMax(double ocTjMax) override;
|
||||
|
||||
WddmFrequencyImp(OsSysman *pOsSysman, ze_bool_t onSubdevice, uint32_t subdeviceId, zes_freq_domain_t type);
|
||||
WddmFrequencyImp() = default;
|
||||
~WddmFrequencyImp() override = default;
|
||||
|
||||
private:
|
||||
ze_result_t setRange(double min, double max);
|
||||
ze_result_t getRange(double *min, double *max);
|
||||
void readOverclockingInfo();
|
||||
bool canControl();
|
||||
ze_result_t applyOcSettings();
|
||||
double minRangeFreq = -1.0;
|
||||
double maxRangeFreq = -1.0;
|
||||
zes_oc_capabilities_t ocCapabilities = {};
|
||||
zes_oc_mode_t currentOcMode = ZES_OC_MODE_OFF;
|
||||
zes_oc_mode_t currentFixedMode = ZES_OC_MODE_OFF;
|
||||
zes_oc_mode_t currentVoltageMode = ZES_OC_MODE_OFF;
|
||||
double currentFrequencyTarget = -1.0;
|
||||
double currentVoltageTarget = -1.0;
|
||||
double currentVoltageOffset = -1.0;
|
||||
|
||||
protected:
|
||||
KmdSysManager *pKmdSysManager = nullptr;
|
||||
zes_freq_domain_t frequencyDomainNumber = ZES_FREQ_DOMAIN_GPU;
|
||||
};
|
||||
|
||||
} // namespace L0
|
||||
Reference in New Issue
Block a user