Change to use support info for interval millis (2a1c9e43) · Commits · e / os / android_frameworks_base

core/java/android/os/health/SystemHealthManager.java

+2 −10

Original line number	Diff line number	Diff line
		@@ -344,11 +344,7 @@ public class SystemHealthManager {
		\|\| !mHintManagerClientData.supportInfo.headroom.isCpuSupported) {
		throw new UnsupportedOperationException();
		}
		try {
		return mHintManager.getCpuHeadroomMinIntervalMillis();
		} catch (RemoteException re) {
		throw re.rethrowFromSystemServer();
		}
		return mHintManagerClientData.supportInfo.headroom.cpuMinIntervalMillis;
		}

		/**
		@@ -366,11 +362,7 @@ public class SystemHealthManager {
		\|\| !mHintManagerClientData.supportInfo.headroom.isGpuSupported) {
		throw new UnsupportedOperationException();
		}
		try {
		return mHintManager.getGpuHeadroomMinIntervalMillis();
		} catch (RemoteException re) {
		throw re.rethrowFromSystemServer();
		}
		return mHintManagerClientData.supportInfo.headroom.gpuMinIntervalMillis;
		}

		/**

core/tests/coretests/src/android/os/SystemHealthManagerUnitTest.java

0 → 100644

+153 −0

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/

		package android.os;

		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.Mockito.times;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.hardware.power.CpuHeadroomResult;
		import android.hardware.power.GpuHeadroomResult;
		import android.hardware.power.SupportInfo;
		import android.os.health.SystemHealthManager;

		import androidx.test.ext.junit.runners.AndroidJUnit4;

		import com.android.internal.app.IBatteryStats;

		import org.junit.Before;
		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.mockito.Mock;
		import org.mockito.MockitoAnnotations;

		@RunWith(AndroidJUnit4.class)
		public class SystemHealthManagerUnitTest {
		@Mock
		private IBatteryStats mBatteryStats;
		@Mock
		private IPowerStatsService mPowerStats;
		@Mock
		private IHintManager mHintManager;
		private SystemHealthManager mSystemHealthManager;

		@Before
		public void setUp() throws Exception {
		MockitoAnnotations.initMocks(this);
		IHintManager.HintManagerClientData clientData = new IHintManager.HintManagerClientData();
		clientData.supportInfo = new SupportInfo();
		clientData.maxCpuHeadroomThreads = 10;
		clientData.supportInfo.headroom = new SupportInfo.HeadroomSupportInfo();
		clientData.supportInfo.headroom.isCpuSupported = true;
		clientData.supportInfo.headroom.isGpuSupported = true;
		clientData.supportInfo.headroom.cpuMinCalculationWindowMillis = 45;
		clientData.supportInfo.headroom.cpuMaxCalculationWindowMillis = 9999;
		clientData.supportInfo.headroom.gpuMinCalculationWindowMillis = 46;
		clientData.supportInfo.headroom.gpuMaxCalculationWindowMillis = 9998;
		clientData.supportInfo.headroom.cpuMinIntervalMillis = 999;
		clientData.supportInfo.headroom.gpuMinIntervalMillis = 998;
		when(mHintManager.getClientData()).thenReturn(clientData);
		mSystemHealthManager = new SystemHealthManager(mBatteryStats, mPowerStats, mHintManager);
		}

		@Test
		public void testHeadroomParamsValueRange() {
		assertEquals(999, mSystemHealthManager.getCpuHeadroomMinIntervalMillis());
		assertEquals(998, mSystemHealthManager.getGpuHeadroomMinIntervalMillis());
		assertEquals(45, (int) mSystemHealthManager.getCpuHeadroomCalculationWindowRange().first);
		assertEquals(9999,
		(int) mSystemHealthManager.getCpuHeadroomCalculationWindowRange().second);
		assertEquals(46, (int) mSystemHealthManager.getGpuHeadroomCalculationWindowRange().first);
		assertEquals(9998,
		(int) mSystemHealthManager.getGpuHeadroomCalculationWindowRange().second);
		assertEquals(10, (int) mSystemHealthManager.getMaxCpuHeadroomTidsSize());
		}

		@Test
		public void testGetCpuHeadroom() throws RemoteException, InterruptedException {
		final CpuHeadroomParams params1 = null;
		final CpuHeadroomParamsInternal internalParams1 = new CpuHeadroomParamsInternal();

		final CpuHeadroomParams params2 = new CpuHeadroomParams.Builder()
		.setCalculationWindowMillis(100)
		.build();
		final CpuHeadroomParamsInternal internalParams2 = new CpuHeadroomParamsInternal();
		internalParams2.calculationWindowMillis = 100;

		final CpuHeadroomParams params3 = new CpuHeadroomParams.Builder()
		.setCalculationType(CpuHeadroomParams.CPU_HEADROOM_CALCULATION_TYPE_AVERAGE)
		.build();
		final CpuHeadroomParamsInternal internalParams3 = new CpuHeadroomParamsInternal();
		internalParams3.calculationType =
		(byte) CpuHeadroomParams.CPU_HEADROOM_CALCULATION_TYPE_AVERAGE;

		final CpuHeadroomParams params4 = new CpuHeadroomParams.Builder()
		.setTids(1000, 1001)
		.build();
		final CpuHeadroomParamsInternal internalParams4 = new CpuHeadroomParamsInternal();
		internalParams4.tids = new int[]{1000, 1001};

		when(mHintManager.getCpuHeadroom(internalParams1)).thenReturn(
		CpuHeadroomResult.globalHeadroom(99f));
		when(mHintManager.getCpuHeadroom(internalParams2)).thenReturn(
		CpuHeadroomResult.globalHeadroom(98f));
		when(mHintManager.getCpuHeadroom(internalParams3)).thenReturn(
		CpuHeadroomResult.globalHeadroom(97f));
		when(mHintManager.getCpuHeadroom(internalParams4)).thenReturn(null);

		assertEquals(99f, mSystemHealthManager.getCpuHeadroom(params1), 0.001f);
		assertEquals(98f, mSystemHealthManager.getCpuHeadroom(params2), 0.001f);
		assertEquals(97f, mSystemHealthManager.getCpuHeadroom(params3), 0.001f);
		assertTrue(Float.isNaN(mSystemHealthManager.getCpuHeadroom(params4)));
		verify(mHintManager, times(1)).getCpuHeadroom(internalParams1);
		verify(mHintManager, times(1)).getCpuHeadroom(internalParams2);
		verify(mHintManager, times(1)).getCpuHeadroom(internalParams3);
		verify(mHintManager, times(1)).getCpuHeadroom(internalParams4);
		}

		@Test
		public void testGetGpuHeadroom() throws RemoteException, InterruptedException {
		final GpuHeadroomParams params1 = null;
		final GpuHeadroomParamsInternal internalParams1 = new GpuHeadroomParamsInternal();
		final GpuHeadroomParams params2 = new GpuHeadroomParams.Builder()
		.setCalculationWindowMillis(100)
		.build();
		final GpuHeadroomParamsInternal internalParams2 = new GpuHeadroomParamsInternal();
		internalParams2.calculationWindowMillis = 100;
		final GpuHeadroomParams params3 = new GpuHeadroomParams.Builder()
		.setCalculationType(GpuHeadroomParams.GPU_HEADROOM_CALCULATION_TYPE_AVERAGE)
		.build();
		final GpuHeadroomParamsInternal internalParams3 = new GpuHeadroomParamsInternal();
		internalParams3.calculationType =
		(byte) GpuHeadroomParams.GPU_HEADROOM_CALCULATION_TYPE_AVERAGE;

		when(mHintManager.getGpuHeadroom(internalParams1)).thenReturn(
		GpuHeadroomResult.globalHeadroom(99f));
		when(mHintManager.getGpuHeadroom(internalParams2)).thenReturn(
		GpuHeadroomResult.globalHeadroom(98f));
		when(mHintManager.getGpuHeadroom(internalParams3)).thenReturn(null);

		assertEquals(99f, mSystemHealthManager.getGpuHeadroom(params1), 0.001f);
		assertEquals(98f, mSystemHealthManager.getGpuHeadroom(params2), 0.001f);
		assertTrue(Float.isNaN(mSystemHealthManager.getGpuHeadroom(params3)));
		verify(mHintManager, times(1)).getGpuHeadroom(internalParams1);
		verify(mHintManager, times(1)).getGpuHeadroom(internalParams2);
		verify(mHintManager, times(1)).getGpuHeadroom(internalParams3);
		}
		}

native/android/libandroid.map.txt

+1 −0

Original line number	Diff line number	Diff line
		@@ -421,6 +421,7 @@ LIBANDROID {
		LIBANDROID_PLATFORM {
		global:
		AThermal_setIThermalServiceForTesting;
		ASystemHealth_setIHintManagerForTesting;
		APerformanceHint_setIHintManagerForTesting;
		APerformanceHint_sendHint;
		APerformanceHint_getThreadIds;

native/android/system_health.cpp

+37 −23

Original line number	Diff line number	Diff line
		@@ -14,6 +14,8 @@
		* limitations under the License.
		*/

		#define LOG_TAG "system_health"

		#include <aidl/android/hardware/power/CpuHeadroomParams.h>
		#include <aidl/android/hardware/power/GpuHeadroomParams.h>
		#include <aidl/android/os/CpuHeadroomParamsInternal.h>
		@@ -23,6 +25,17 @@
		#include <android/system_health.h>
		#include <binder/IServiceManager.h>
		#include <binder/Status.h>
		#include <system_health_private.h>

		#include <list>
		#include <map>
		#include <memory>
		#include <mutex>
		#include <optional>
		#include <utility>

		#include "android-base/thread_annotations.h"
		#include "utils/SystemClock.h"

		using namespace android;
		using namespace aidl::android::os;
		@@ -55,9 +68,20 @@ private:
		IHintManager::HintManagerClientData mClientData;
		};

		static std::shared_ptr<IHintManager>* gIHintManagerForTesting = nullptr;
		static std::shared_ptr<ASystemHealthManager> gSystemHealthManagerForTesting = nullptr;

		ASystemHealthManager* ASystemHealthManager::getInstance() {
		static std::once_flag creationFlag;
		static ASystemHealthManager* instance = nullptr;
		if (gSystemHealthManagerForTesting) {
		return gSystemHealthManagerForTesting.get();
		}
		if (gIHintManagerForTesting) {
		gSystemHealthManagerForTesting =
		std::shared_ptr<ASystemHealthManager>(create(*gIHintManagerForTesting));
		return gSystemHealthManagerForTesting.get();
		}
		std::call_once(creationFlag, []() { instance = create(nullptr); });
		return instance;
		}
		@@ -121,7 +145,8 @@ int ASystemHealthManager::getCpuHeadroom(const ACpuHeadroomParams* params, float
		}
		return EPIPE;
		}
		*outHeadroom = res->get<hal::CpuHeadroomResult::Tag::globalHeadroom>();
		*outHeadroom = res ? res->get<hal::CpuHeadroomResult::Tag::globalHeadroom>()
		: std::numeric_limits<float>::quiet_NaN();
		return OK;
		}

		@@ -155,37 +180,20 @@ int ASystemHealthManager::getGpuHeadroom(const AGpuHeadroomParams* params, float
		}
		return EPIPE;
		}
		*outHeadroom = res->get<hal::GpuHeadroomResult::Tag::globalHeadroom>();
		*outHeadroom = res ? res->get<hal::GpuHeadroomResult::Tag::globalHeadroom>()
		: std::numeric_limits<float>::quiet_NaN();
		return OK;
		}

		int ASystemHealthManager::getCpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
		if (!mClientData.supportInfo.headroom.isCpuSupported) return ENOTSUP;
		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;
		*outMinIntervalMillis = mClientData.supportInfo.headroom.cpuMinIntervalMillis;
		return OK;
		}

		int ASystemHealthManager::getGpuHeadroomMinIntervalMillis(int64_t* outMinIntervalMillis) {
		if (!mClientData.supportInfo.headroom.isGpuSupported) return ENOTSUP;
		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;
		*outMinIntervalMillis = mClientData.supportInfo.headroom.gpuMinIntervalMillis;
		return OK;
		}

		@@ -298,7 +306,6 @@ void ACpuHeadroomParams_setTids(ACpuHeadroomParams* _Nonnull params, const int*
		size_t tidsSize) {
		LOG_ALWAYS_FATAL_IF(tids == nullptr, "%s: tids should not be null", __FUNCTION__);
		params->tids.resize(tidsSize);
		params->tids.clear();
		for (int i = 0; i < (int)tidsSize; ++i) {
		LOG_ALWAYS_FATAL_IF(tids[i] <= 0, "ACpuHeadroomParams_setTids: Invalid non-positive tid %d",
		tids[i]);
		@@ -355,3 +362,10 @@ void ACpuHeadroomParams_destroy(ACpuHeadroomParams* _Nullable params) {
		void AGpuHeadroomParams_destroy(AGpuHeadroomParams* _Nullable params) {
		delete params;
		}

		void ASystemHealth_setIHintManagerForTesting(void* iManager) {
		if (iManager == nullptr) {
		gSystemHealthManagerForTesting = nullptr;
		}
		gIHintManagerForTesting = static_cast<std::shared_ptr<IHintManager>*>(iManager);
		}

native/android/tests/system_health/Android.bp

0 → 100644

+66 −0

Original line number	Diff line number	Diff line
		// 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.

		package {
		// See: http://go/android-license-faq
		// A large-scale-change added 'default_applicable_licenses' to import
		// all of the 'license_kinds' from "frameworks_base_license"
		// to get the below license kinds:
		// SPDX-license-identifier-Apache-2.0
		default_applicable_licenses: ["frameworks_base_license"],
		}

		cc_test {
		name: "NativeSystemHealthUnitTestCases",

		multilib: {
		lib32: {
		suffix: "32",
		},
		lib64: {
		suffix: "64",
		},
		},

		srcs: ["NativeSystemHealthUnitTest.cpp"],

		shared_libs: [
		"libandroid",
		"libbinder",
		"libbinder_ndk",
		"liblog",
		"libpowermanager",
		"libutils",
		],

		static_libs: [
		"libbase",
		"libgmock",
		"libgtest",
		],
		stl: "c++_shared",

		test_suites: [
		"device-tests",
		],

		cflags: [
		"-Wall",
		"-Werror",
		],

		header_libs: [
		"libandroid_headers_private",
		],
		}