void PolicyServicesDomainActiveControl::setActiveControl(UIntN participantIndex, UIntN domainIndex,
const Percentage& fanSpeed)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setActiveControl(domainIndex,
getPolicyIndex(), fanSpeed);
}
void PolicyServicesDomainRfProfileControl::setRfProfileCenterFrequency(UIntN participantIndex, UIntN domainIndex,
const Frequency& centerFrequency)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setRfProfileCenterFrequency(domainIndex,
getPolicyIndex(), centerFrequency);
}
void PolicyServicesDomainCoreControl::setActiveCoreControl(UIntN participantIndex, UIntN domainIndex,
const CoreControlStatus& coreControlStatus)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setActiveCoreControl(domainIndex,
getPolicyIndex(), coreControlStatus);
}
Temperature PolicyServicesDomainTemperature::getPowerShareTemperatureThreshold(
UIntN participantIndex,
UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getPowerShareTemperatureThreshold(domainIndex);
}
void PolicyServicesDomainTemperature::setVirtualTemperature(
UIntN participantIndex,
UIntN domainIndex,
const Temperature& temperature)
{
throwIfNotWorkItemThread();
return getParticipantManager()
->getParticipantPtr(participantIndex)
->setVirtualTemperature(domainIndex, temperature);
}
void WIDptfConnectedStandbyEntry::execute(void)
{
writeWorkItemStartingInfoMessage();
// First let all policies know that we are entering connected standby
auto policyManager = getPolicyManager();
auto policyIndexes = policyManager->getPolicyIndexes();
for (auto i = policyIndexes.begin(); i != policyIndexes.end(); ++i)
{
try
{
Policy* policy = policyManager->getPolicyPtr(*i);
policy->executeConnectedStandbyEntry();
}
catch (policy_index_invalid& ex)
{
// do nothing. No item in the policy list at this index.
}
catch (std::exception& ex)
{
writeWorkItemErrorMessagePolicy(ex, "Policy::executeConnectedStandbyEntry", *i);
}
}
// Now let all participants know
auto participantManager = getParticipantManager();
auto participantIndexList = participantManager->getParticipantIndexes();
for (auto i = participantIndexList.begin(); i != participantIndexList.end(); ++i)
{
try
{
Participant* participant = participantManager->getParticipantPtr(*i);
participant->connectedStandbyEntry();
}
catch (participant_index_invalid& ex)
{
// do nothing. No item in the participant list at this index.
}
catch (std::exception& ex)
{
writeWorkItemErrorMessageParticipant(ex, "Participant::connectedStandbyEntry", *i);
}
}
}
void PolicyServicesDomainTemperature::setTemperatureThresholds(UIntN participantIndex,
UIntN domainIndex, const TemperatureThresholds& temperatureThresholds)
{
throwIfNotWorkItemThread();
#ifdef ONLY_LOG_TEMPERATURE_THRESHOLDS
// Added to help debug issue with missing temperature threshold events
ManagerMessage message = ManagerMessage(getDptfManager(), FLF,
"Policy is calling PolicyServicesDomainTemperature::setTemperatureThresholds().");
message.addMessage("Aux0", temperatureThresholds.getAux0());
message.addMessage("Aux1", temperatureThresholds.getAux1());
message.setParticipantAndDomainIndex(participantIndex, domainIndex);
message.setPolicyIndex(getPolicyIndex());
getDptfManager()->getEsifServices()->writeMessageDebug(message, MessageCategory::TemperatureThresholds);
#endif
getParticipantManager()->getParticipantPtr(participantIndex)->setTemperatureThresholds(
domainIndex, getPolicyIndex(), temperatureThresholds);
}
void WIPolicyReload::execute(void)
{
writeWorkItemStartingInfoMessage();
// Iterate through the list of policies and unbind all participant and domains from them
DptfManagerInterface* dptfManager = getDptfManager();
auto policyManager = getPolicyManager();
auto participantIndexList = getParticipantManager()->getParticipantIndexes();
// Unbind every participant and domain from every policy
for (auto participantIndex = participantIndexList.begin(); participantIndex != participantIndexList.end(); ++participantIndex)
{
dptfManager->unbindDomainsFromPolicies(*participantIndex);
dptfManager->unbindParticipantFromPolicies(*participantIndex);
}
// No try-catch here because destroyAllPolicies' calling tree catches all exceptions.
policyManager->destroyAllPolicies();
try
{
policyManager->reloadAllPolicies(dptfManager->getDptfPolicyDirectoryPath());
}
catch (dptf_exception ex)
{
writeWorkItemErrorMessage(ex, "policyManager::reloadAllPolicies");
}
// Bind every participant and domain to every policy
for (auto participantIndex = participantIndexList.begin(); participantIndex != participantIndexList.end(); ++participantIndex)
{
dptfManager->bindParticipantToPolicies(*participantIndex);
dptfManager->bindDomainsToPolicies(*participantIndex);
}
}
void PolicyServicesParticipantSetSpecificInfo::setParticipantDeviceTemperatureIndication(
UIntN participantIndex, const Temperature& temperature)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setParticipantDeviceTemperatureIndication(temperature);
}
CoreControlStatus PolicyServicesDomainCoreControl::getCoreControlStatus(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getCoreControlStatus(domainIndex);
}
UtilizationStatus PolicyServicesDomainUtilization::getUtilizationStatus(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getUtilizationStatus(domainIndex);
}
TemperatureStatus PolicyServicesDomainTemperature::getTemperatureStatus(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getTemperatureStatus(domainIndex);
}
void PolicyServicesDomainHardwareDutyCycleControl::setHardwareDutyCycle(
UIntN participantIndex, UIntN domainIndex, const Percentage& dutyCycle)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setHardwareDutyCycle(domainIndex, dutyCycle);
}
DptfBuffer PolicyServicesDomainHardwareDutyCycleControl::getHardwareDutyCycleUtilizationSet(
UIntN participantIndex, UIntN domainIndex) const
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getHardwareDutyCycleUtilizationSet(domainIndex);
}
DptfBuffer PolicyServicesDomainTemperature::getPollingTable(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getVirtualSensorPollingTable(domainIndex);
}
RfProfileCapabilities PolicyServicesDomainRfProfileControl::getRfProfileCapabilities(UIntN participantIndex,
UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getRfProfileCapabilities(domainIndex);
}
Bool PolicyServicesDomainHardwareDutyCycleControl::isSupportedByOperatingSystem(
UIntN participantIndex, UIntN domainIndex) const
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->isSupportedByOperatingSystem(domainIndex);
}
std::map<ParticipantSpecificInfoKey::Type, UIntN> PolicyServicesParticipantGetSpecificInfo::getParticipantSpecificInfo(
UIntN participantIndex, const std::vector<ParticipantSpecificInfoKey::Type>& requestedInfo)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getParticipantSpecificInfo(requestedInfo);
}
DomainPropertiesSet PolicyServicesParticipantProperties::getDomainPropertiesSet(UIntN participantIndex) const
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getDomainPropertiesSet();
}
Percentage PolicyServicesDomainHardwareDutyCycleControl::getHardwareDutyCycle(
UIntN participantIndex, UIntN domainIndex) const
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getHardwareDutyCycle(domainIndex);
}
TimeSpan PolicyServicesDomainPlatformPowerStatus::getACPeakTimeWindow(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
auto participant = getParticipantManager()->getParticipantPtr(participantIndex);
return participant->getACPeakTimeWindow(domainIndex);
}
Bool PolicyServicesDomainTemperature::isVirtualTemperature(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->isVirtualTemperature(domainIndex);
}
Power PolicyServicesDomainPlatformPowerStatus::getPlatformBatterySteadyState(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
auto participant = getParticipantManager()->getParticipantPtr(participantIndex);
return participant->getPlatformBatterySteadyState(domainIndex);
}
void PolicyServicesParticipantSetSpecificInfo::setParticipantCoolingPolicy(
UIntN participantIndex, const CoolingPreference& coolingPreference)
{
throwIfNotWorkItemThread();
getParticipantManager()->getParticipantPtr(participantIndex)->setParticipantCoolingPolicy(coolingPreference);
}
ActiveControlSet PolicyServicesDomainActiveControl::getActiveControlSet(UIntN participantIndex, UIntN domainIndex)
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->getActiveControlSet(domainIndex);
}
Bool PolicyServicesDomainHardwareDutyCycleControl::isHdcOobEnabled(
UIntN participantIndex, UIntN domainIndex) const
{
throwIfNotWorkItemThread();
return getParticipantManager()->getParticipantPtr(participantIndex)->isHdcOobEnabled(domainIndex);
}
