native/android/system_health.cpp - android_frameworks_base - Gitiles

 /*
  * Copyright (C) 2024 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include <aidl/android/hardware/power/CpuHeadroomParams.h>
 #include <aidl/android/hardware/power/GpuHeadroomParams.h>
 #include <aidl/android/os/CpuHeadroomParamsInternal.h>
 #include <aidl/android/os/GpuHeadroomParamsInternal.h>
 #include <aidl/android/os/IHintManager.h>
 #include <android/binder_manager.h>
 #include <android/system_health.h>
 #include <binder/IServiceManager.h>
 #include <binder/Status.h>

 using namespace android;
 using namespace aidl::android::os;
 namespace hal = aidl::android::hardware::power;

 struct ACpuHeadroomParams : public CpuHeadroomParamsInternal {};
 struct AGpuHeadroomParams : public GpuHeadroomParamsInternal {};

 const int CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN = 50;
 const int CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX = 10000;
 const int GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN = 50;
 const int GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX = 10000;
 const int CPU_HEADROOM_MAX_TID_COUNT = 5;

 struct ASystemHealthManager {
 public:
     static ASystemHealthManager* getInstance();
     ASystemHealthManager(std::shared_ptr<IHintManager>& hintManager);
     ASystemHealthManager() = delete;
     ~ASystemHealthManager();
     int getCpuHeadroom(const ACpuHeadroomParams* params, float* outHeadroom);
     int getGpuHeadroom(const AGpuHeadroomParams* params, float* outHeadroom);
     int getCpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis);
     int getGpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis);

 private:
     static ASystemHealthManager* create(std::shared_ptr<IHintManager> hintManager);
     std::shared_ptr<IHintManager> mHintManager;
 };

 ASystemHealthManager* ASystemHealthManager::getInstance() {
     static std::once_flag creationFlag;
     static ASystemHealthManager* instance = nullptr;
     std::call_once(creationFlag, []() { instance = create(nullptr); });
     return instance;
 }

 ASystemHealthManager::ASystemHealthManager(std::shared_ptr<IHintManager>& hintManager)
       : mHintManager(std::move(hintManager)) {}

 ASystemHealthManager::~ASystemHealthManager() {}

 ASystemHealthManager* ASystemHealthManager::create(std::shared_ptr<IHintManager> hintManager) {
     if (!hintManager) {
         hintManager = IHintManager::fromBinder(
                 ndk::SpAIBinder(AServiceManager_waitForService("performance_hint")));
     }
     if (hintManager == nullptr) {
         ALOGE("%s: PerformanceHint service is not ready ", __FUNCTION__);
         return nullptr;
     }
     return new ASystemHealthManager(hintManager);
 }

 ASystemHealthManager* ASystemHealth_acquireManager() {
     return ASystemHealthManager::getInstance();
 }

 int ASystemHealthManager::getCpuHeadroom(const ACpuHeadroomParams* params, float* outHeadroom) {
     std::optional<hal::CpuHeadroomResult> res;
     ::ndk::ScopedAStatus ret;
     CpuHeadroomParamsInternal internalParams;
     if (!params) {
         ret = mHintManager->getCpuHeadroom(internalParams, &res);
     } else {
         ret = mHintManager->getCpuHeadroom(*params, &res);
     }
     if (!ret.isOk()) {
         LOG_ALWAYS_FATAL_IF(ret.getExceptionCode() == EX_ILLEGAL_ARGUMENT,
                             "Invalid ACpuHeadroomParams: %s", ret.getMessage());
         ALOGE("ASystemHealth_getCpuHeadroom fails: %s", ret.getMessage());
         if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
             return ENOTSUP;
         } else if (ret.getExceptionCode() == EX_SECURITY) {
             return EPERM;
         }
         return EPIPE;
     }
     *outHeadroom = res->get<hal::CpuHeadroomResult::Tag::globalHeadroom>();
     return OK;
 }

 int ASystemHealthManager::getGpuHeadroom(const AGpuHeadroomParams* params, float* outHeadroom) {
     std::optional<hal::GpuHeadroomResult> res;
     ::ndk::ScopedAStatus ret;
     GpuHeadroomParamsInternal internalParams;
     if (!params) {
         ret = mHintManager->getGpuHeadroom(internalParams, &res);
     } else {
         ret = mHintManager->getGpuHeadroom(*params, &res);
     }
     if (!ret.isOk()) {
         LOG_ALWAYS_FATAL_IF(ret.getExceptionCode() == EX_ILLEGAL_ARGUMENT,
                             "Invalid AGpuHeadroomParams: %s", ret.getMessage());
         ALOGE("ASystemHealth_getGpuHeadroom fails: %s", ret.getMessage());
         if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
             return ENOTSUP;
         }
         return EPIPE;
     }
     *outHeadroom = res->get<hal::GpuHeadroomResult::Tag::globalHeadroom>();
     return OK;
 }

 int ASystemHealthManager::getCpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
     int64_t minIntervalMillis = 0;
     ::ndk::ScopedAStatus ret = mHintManager->getCpuHeadroomMinIntervalMillis(&minIntervalMillis);
     if (!ret.isOk()) {
         ALOGE("ASystemHealth_getCpuHeadroomMinIntervalMillis fails: %s", ret.getMessage());
         if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
             return ENOTSUP;
         }
         return EPIPE;
     }
     *outMinIntervalMillis = minIntervalMillis;
     return OK;
 }

 int ASystemHealthManager::getGpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
     int64_t minIntervalMillis = 0;
     ::ndk::ScopedAStatus ret = mHintManager->getGpuHeadroomMinIntervalMillis(&minIntervalMillis);
     if (!ret.isOk()) {
         ALOGE("ASystemHealth_getGpuHeadroomMinIntervalMillis fails: %s", ret.getMessage());
         if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
             return ENOTSUP;
         }
         return EPIPE;
     }
     *outMinIntervalMillis = minIntervalMillis;
     return OK;
 }

 int ASystemHealth_getCpuHeadroom(const ACpuHeadroomParams* _Nullable params,
                                  float* _Nonnull outHeadroom) {
     LOG_ALWAYS_FATAL_IF(outHeadroom == nullptr, "%s: outHeadroom should not be null", __FUNCTION__);
     auto manager = ASystemHealthManager::getInstance();
     if (manager == nullptr) return ENOTSUP;
     return manager->getCpuHeadroom(params, outHeadroom);
 }

 int ASystemHealth_getGpuHeadroom(const AGpuHeadroomParams* _Nullable params,
                                  float* _Nonnull outHeadroom) {
     LOG_ALWAYS_FATAL_IF(outHeadroom == nullptr, "%s: outHeadroom should not be null", __FUNCTION__);
     auto manager = ASystemHealthManager::getInstance();
     if (manager == nullptr) return ENOTSUP;
     return manager->getGpuHeadroom(params, outHeadroom);
 }

 int ASystemHealth_getCpuHeadroomMinIntervalMillis(int64_t* _Nonnull outMinIntervalMillis) {
     LOG_ALWAYS_FATAL_IF(outMinIntervalMillis == nullptr,
                         "%s: outMinIntervalMillis should not be null", __FUNCTION__);
     auto manager = ASystemHealthManager::getInstance();
     if (manager == nullptr) return ENOTSUP;
     return manager->getCpuHeadroomMinIntervalMillis(outMinIntervalMillis);
 }

 int ASystemHealth_getGpuHeadroomMinIntervalMillis(int64_t* _Nonnull outMinIntervalMillis) {
     LOG_ALWAYS_FATAL_IF(outMinIntervalMillis == nullptr,
                         "%s: outMinIntervalMillis should not be null", __FUNCTION__);
     auto manager = ASystemHealthManager::getInstance();
     if (manager == nullptr) return ENOTSUP;
     return manager->getGpuHeadroomMinIntervalMillis(outMinIntervalMillis);
 }

 void ACpuHeadroomParams_setCalculationWindowMillis(ACpuHeadroomParams* _Nonnull params,
                                                    int windowMillis) {
     LOG_ALWAYS_FATAL_IF(windowMillis < CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN ||
                                 windowMillis > CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX,
                         "%s: windowMillis should be in range [50, 10000] but got %d", __FUNCTION__,
                         windowMillis);
     params->calculationWindowMillis = windowMillis;
 }

 void AGpuHeadroomParams_setCalculationWindowMillis(AGpuHeadroomParams* _Nonnull params,
                                                    int windowMillis) {
     LOG_ALWAYS_FATAL_IF(windowMillis < GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN ||
                                 windowMillis > GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX,
                         "%s: windowMillis should be in range [50, 10000] but got %d", __FUNCTION__,
                         windowMillis);
     params->calculationWindowMillis = windowMillis;
 }

 int ACpuHeadroomParams_getCalculationWindowMillis(ACpuHeadroomParams* _Nonnull params) {
     return params->calculationWindowMillis;
 }

 int AGpuHeadroomParams_getCalculationWindowMillis(AGpuHeadroomParams* _Nonnull params) {
     return params->calculationWindowMillis;
 }

 void ACpuHeadroomParams_setTids(ACpuHeadroomParams* _Nonnull params, const int* _Nonnull tids,
                                 int tidsSize) {
     LOG_ALWAYS_FATAL_IF(tids == nullptr, "%s: tids should not be null", __FUNCTION__);
     LOG_ALWAYS_FATAL_IF(tidsSize > CPU_HEADROOM_MAX_TID_COUNT, "%s: tids size should not exceed 5",
                         __FUNCTION__);
     params->tids.resize(tidsSize);
     params->tids.clear();
     for (int i = 0; i < tidsSize; ++i) {
         LOG_ALWAYS_FATAL_IF(tids[i] <= 0, "ACpuHeadroomParams_setTids: Invalid non-positive tid %d",
                             tids[i]);
         params->tids[i] = tids[i];
     }
 }

 void ACpuHeadroomParams_setCalculationType(ACpuHeadroomParams* _Nonnull params,
                                            ACpuHeadroomCalculationType calculationType) {
     LOG_ALWAYS_FATAL_IF(calculationType < ACpuHeadroomCalculationType::
                                                   ACPU_HEADROOM_CALCULATION_TYPE_MIN ||
                                 calculationType > ACpuHeadroomCalculationType::
                                                           ACPU_HEADROOM_CALCULATION_TYPE_AVERAGE,
                         "%s: calculationType should be one of ACpuHeadroomCalculationType values "
                         "but got %d",
                         __FUNCTION__, calculationType);
     params->calculationType = static_cast<hal::CpuHeadroomParams::CalculationType>(calculationType);
 }

 ACpuHeadroomCalculationType ACpuHeadroomParams_getCalculationType(
         ACpuHeadroomParams* _Nonnull params) {
     return static_cast<ACpuHeadroomCalculationType>(params->calculationType);
 }

 void AGpuHeadroomParams_setCalculationType(AGpuHeadroomParams* _Nonnull params,
                                            AGpuHeadroomCalculationType calculationType) {
     LOG_ALWAYS_FATAL_IF(calculationType < AGpuHeadroomCalculationType::
                                                   AGPU_HEADROOM_CALCULATION_TYPE_MIN ||
                                 calculationType > AGpuHeadroomCalculationType::
                                                           AGPU_HEADROOM_CALCULATION_TYPE_AVERAGE,
                         "%s: calculationType should be one of AGpuHeadroomCalculationType values "
                         "but got %d",
                         __FUNCTION__, calculationType);
     params->calculationType = static_cast<hal::GpuHeadroomParams::CalculationType>(calculationType);
 }

 AGpuHeadroomCalculationType AGpuHeadroomParams_getCalculationType(
         AGpuHeadroomParams* _Nonnull params) {
     return static_cast<AGpuHeadroomCalculationType>(params->calculationType);
 }

 ACpuHeadroomParams* _Nonnull ACpuHeadroomParams_create() {
     return new ACpuHeadroomParams();
 }

 AGpuHeadroomParams* _Nonnull AGpuHeadroomParams_create() {
     return new AGpuHeadroomParams();
 }

 void ACpuHeadroomParams_destroy(ACpuHeadroomParams* _Nonnull params) {
     delete params;
 }

 void AGpuHeadroomParams_destroy(AGpuHeadroomParams* _Nonnull params) {
     delete params;
 }
	/*
	* Copyright (C) 2024 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include <aidl/android/hardware/power/CpuHeadroomParams.h>
	#include <aidl/android/hardware/power/GpuHeadroomParams.h>
	#include <aidl/android/os/CpuHeadroomParamsInternal.h>
	#include <aidl/android/os/GpuHeadroomParamsInternal.h>
	#include <aidl/android/os/IHintManager.h>
	#include <android/binder_manager.h>
	#include <android/system_health.h>
	#include <binder/IServiceManager.h>
	#include <binder/Status.h>

	using namespace android;
	using namespace aidl::android::os;
	namespace hal = aidl::android::hardware::power;

	struct ACpuHeadroomParams : public CpuHeadroomParamsInternal {};
	struct AGpuHeadroomParams : public GpuHeadroomParamsInternal {};

	const int CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN = 50;
	const int CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX = 10000;
	const int GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN = 50;
	const int GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX = 10000;
	const int CPU_HEADROOM_MAX_TID_COUNT = 5;

	struct ASystemHealthManager {
	public:
	static ASystemHealthManager* getInstance();
	ASystemHealthManager(std::shared_ptr<IHintManager>& hintManager);
	ASystemHealthManager() = delete;
	~ASystemHealthManager();
	int getCpuHeadroom(const ACpuHeadroomParams* params, float* outHeadroom);
	int getGpuHeadroom(const AGpuHeadroomParams* params, float* outHeadroom);
	int getCpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis);
	int getGpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis);

	private:
	static ASystemHealthManager* create(std::shared_ptr<IHintManager> hintManager);
	std::shared_ptr<IHintManager> mHintManager;
	};

	ASystemHealthManager* ASystemHealthManager::getInstance() {
	static std::once_flag creationFlag;
	static ASystemHealthManager* instance = nullptr;
	std::call_once(creationFlag, []() { instance = create(nullptr); });
	return instance;
	}

	ASystemHealthManager::ASystemHealthManager(std::shared_ptr<IHintManager>& hintManager)
	: mHintManager(std::move(hintManager)) {}

	ASystemHealthManager::~ASystemHealthManager() {}

	ASystemHealthManager* ASystemHealthManager::create(std::shared_ptr<IHintManager> hintManager) {
	if (!hintManager) {
	hintManager = IHintManager::fromBinder(
	ndk::SpAIBinder(AServiceManager_waitForService("performance_hint")));
	}
	if (hintManager == nullptr) {
	ALOGE("%s: PerformanceHint service is not ready ", __FUNCTION__);
	return nullptr;
	}
	return new ASystemHealthManager(hintManager);
	}

	ASystemHealthManager* ASystemHealth_acquireManager() {
	return ASystemHealthManager::getInstance();
	}

	int ASystemHealthManager::getCpuHeadroom(const ACpuHeadroomParams* params, float* outHeadroom) {
	std::optional<hal::CpuHeadroomResult> res;
	::ndk::ScopedAStatus ret;
	CpuHeadroomParamsInternal internalParams;
	if (!params) {
	ret = mHintManager->getCpuHeadroom(internalParams, &res);
	} else {
	ret = mHintManager->getCpuHeadroom(*params, &res);
	}
	if (!ret.isOk()) {
	LOG_ALWAYS_FATAL_IF(ret.getExceptionCode() == EX_ILLEGAL_ARGUMENT,
	"Invalid ACpuHeadroomParams: %s", ret.getMessage());
	ALOGE("ASystemHealth_getCpuHeadroom fails: %s", ret.getMessage());
	if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
	return ENOTSUP;
	} else if (ret.getExceptionCode() == EX_SECURITY) {
	return EPERM;
	}
	return EPIPE;
	}
	*outHeadroom = res->get<hal::CpuHeadroomResult::Tag::globalHeadroom>();
	return OK;
	}

	int ASystemHealthManager::getGpuHeadroom(const AGpuHeadroomParams* params, float* outHeadroom) {
	std::optional<hal::GpuHeadroomResult> res;
	::ndk::ScopedAStatus ret;
	GpuHeadroomParamsInternal internalParams;
	if (!params) {
	ret = mHintManager->getGpuHeadroom(internalParams, &res);
	} else {
	ret = mHintManager->getGpuHeadroom(*params, &res);
	}
	if (!ret.isOk()) {
	LOG_ALWAYS_FATAL_IF(ret.getExceptionCode() == EX_ILLEGAL_ARGUMENT,
	"Invalid AGpuHeadroomParams: %s", ret.getMessage());
	ALOGE("ASystemHealth_getGpuHeadroom fails: %s", ret.getMessage());
	if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
	return ENOTSUP;
	}
	return EPIPE;
	}
	*outHeadroom = res->get<hal::GpuHeadroomResult::Tag::globalHeadroom>();
	return OK;
	}

	int ASystemHealthManager::getCpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
	int64_t minIntervalMillis = 0;
	::ndk::ScopedAStatus ret = mHintManager->getCpuHeadroomMinIntervalMillis(&minIntervalMillis);
	if (!ret.isOk()) {
	ALOGE("ASystemHealth_getCpuHeadroomMinIntervalMillis fails: %s", ret.getMessage());
	if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
	return ENOTSUP;
	}
	return EPIPE;
	}
	*outMinIntervalMillis = minIntervalMillis;
	return OK;
	}

	int ASystemHealthManager::getGpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
	int64_t minIntervalMillis = 0;
	::ndk::ScopedAStatus ret = mHintManager->getGpuHeadroomMinIntervalMillis(&minIntervalMillis);
	if (!ret.isOk()) {
	ALOGE("ASystemHealth_getGpuHeadroomMinIntervalMillis fails: %s", ret.getMessage());
	if (ret.getExceptionCode() == EX_UNSUPPORTED_OPERATION) {
	return ENOTSUP;
	}
	return EPIPE;
	}
	*outMinIntervalMillis = minIntervalMillis;
	return OK;
	}

	int ASystemHealth_getCpuHeadroom(const ACpuHeadroomParams* _Nullable params,
	float* _Nonnull outHeadroom) {
	LOG_ALWAYS_FATAL_IF(outHeadroom == nullptr, "%s: outHeadroom should not be null", __FUNCTION__);
	auto manager = ASystemHealthManager::getInstance();
	if (manager == nullptr) return ENOTSUP;
	return manager->getCpuHeadroom(params, outHeadroom);
	}

	int ASystemHealth_getGpuHeadroom(const AGpuHeadroomParams* _Nullable params,
	float* _Nonnull outHeadroom) {
	LOG_ALWAYS_FATAL_IF(outHeadroom == nullptr, "%s: outHeadroom should not be null", __FUNCTION__);
	auto manager = ASystemHealthManager::getInstance();
	if (manager == nullptr) return ENOTSUP;
	return manager->getGpuHeadroom(params, outHeadroom);
	}

	int ASystemHealth_getCpuHeadroomMinIntervalMillis(int64_t* _Nonnull outMinIntervalMillis) {
	LOG_ALWAYS_FATAL_IF(outMinIntervalMillis == nullptr,
	"%s: outMinIntervalMillis should not be null", __FUNCTION__);
	auto manager = ASystemHealthManager::getInstance();
	if (manager == nullptr) return ENOTSUP;
	return manager->getCpuHeadroomMinIntervalMillis(outMinIntervalMillis);
	}

	int ASystemHealth_getGpuHeadroomMinIntervalMillis(int64_t* _Nonnull outMinIntervalMillis) {
	LOG_ALWAYS_FATAL_IF(outMinIntervalMillis == nullptr,
	"%s: outMinIntervalMillis should not be null", __FUNCTION__);
	auto manager = ASystemHealthManager::getInstance();
	if (manager == nullptr) return ENOTSUP;
	return manager->getGpuHeadroomMinIntervalMillis(outMinIntervalMillis);
	}

	void ACpuHeadroomParams_setCalculationWindowMillis(ACpuHeadroomParams* _Nonnull params,
	int windowMillis) {
	LOG_ALWAYS_FATAL_IF(windowMillis < CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN \|\|
	windowMillis > CPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX,
	"%s: windowMillis should be in range [50, 10000] but got %d", __FUNCTION__,
	windowMillis);
	params->calculationWindowMillis = windowMillis;
	}

	void AGpuHeadroomParams_setCalculationWindowMillis(AGpuHeadroomParams* _Nonnull params,
	int windowMillis) {
	LOG_ALWAYS_FATAL_IF(windowMillis < GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MIN \|\|
	windowMillis > GPU_HEADROOM_CALCULATION_WINDOW_MILLIS_MAX,
	"%s: windowMillis should be in range [50, 10000] but got %d", __FUNCTION__,
	windowMillis);
	params->calculationWindowMillis = windowMillis;
	}

	int ACpuHeadroomParams_getCalculationWindowMillis(ACpuHeadroomParams* _Nonnull params) {
	return params->calculationWindowMillis;
	}

	int AGpuHeadroomParams_getCalculationWindowMillis(AGpuHeadroomParams* _Nonnull params) {
	return params->calculationWindowMillis;
	}

	void ACpuHeadroomParams_setTids(ACpuHeadroomParams* _Nonnull params, const int* _Nonnull tids,
	int tidsSize) {
	LOG_ALWAYS_FATAL_IF(tids == nullptr, "%s: tids should not be null", __FUNCTION__);
	LOG_ALWAYS_FATAL_IF(tidsSize > CPU_HEADROOM_MAX_TID_COUNT, "%s: tids size should not exceed 5",
	__FUNCTION__);
	params->tids.resize(tidsSize);
	params->tids.clear();
	for (int i = 0; i < tidsSize; ++i) {
	LOG_ALWAYS_FATAL_IF(tids[i] <= 0, "ACpuHeadroomParams_setTids: Invalid non-positive tid %d",
	tids[i]);
	params->tids[i] = tids[i];
	}
	}

	void ACpuHeadroomParams_setCalculationType(ACpuHeadroomParams* _Nonnull params,
	ACpuHeadroomCalculationType calculationType) {
	LOG_ALWAYS_FATAL_IF(calculationType < ACpuHeadroomCalculationType::
	ACPU_HEADROOM_CALCULATION_TYPE_MIN \|\|
	calculationType > ACpuHeadroomCalculationType::
	ACPU_HEADROOM_CALCULATION_TYPE_AVERAGE,
	"%s: calculationType should be one of ACpuHeadroomCalculationType values "
	"but got %d",
	__FUNCTION__, calculationType);
	params->calculationType = static_cast<hal::CpuHeadroomParams::CalculationType>(calculationType);
	}

	ACpuHeadroomCalculationType ACpuHeadroomParams_getCalculationType(
	ACpuHeadroomParams* _Nonnull params) {
	return static_cast<ACpuHeadroomCalculationType>(params->calculationType);
	}

	void AGpuHeadroomParams_setCalculationType(AGpuHeadroomParams* _Nonnull params,
	AGpuHeadroomCalculationType calculationType) {
	LOG_ALWAYS_FATAL_IF(calculationType < AGpuHeadroomCalculationType::
	AGPU_HEADROOM_CALCULATION_TYPE_MIN \|\|
	calculationType > AGpuHeadroomCalculationType::
	AGPU_HEADROOM_CALCULATION_TYPE_AVERAGE,
	"%s: calculationType should be one of AGpuHeadroomCalculationType values "
	"but got %d",
	__FUNCTION__, calculationType);
	params->calculationType = static_cast<hal::GpuHeadroomParams::CalculationType>(calculationType);
	}

	AGpuHeadroomCalculationType AGpuHeadroomParams_getCalculationType(
	AGpuHeadroomParams* _Nonnull params) {
	return static_cast<AGpuHeadroomCalculationType>(params->calculationType);
	}

	ACpuHeadroomParams* _Nonnull ACpuHeadroomParams_create() {
	return new ACpuHeadroomParams();
	}

	AGpuHeadroomParams* _Nonnull AGpuHeadroomParams_create() {
	return new AGpuHeadroomParams();
	}

	void ACpuHeadroomParams_destroy(ACpuHeadroomParams* _Nonnull params) {
	delete params;
	}

	void AGpuHeadroomParams_destroy(AGpuHeadroomParams* _Nonnull params) {
	delete params;
	}