Merge "Add ability to increase light idle time linearly." into main (0f2be544) · Commits · e / os / android_frameworks_base

apex/jobscheduler/service/java/com/android/server/DeviceIdleController.java

+95 −4

Original line number	Diff line number	Diff line
		@@ -1030,6 +1030,12 @@ public class DeviceIdleController extends SystemService
		"light_idle_to_initial_flex";
		private static final String KEY_LIGHT_IDLE_TIMEOUT_MAX_FLEX = "light_max_idle_to_flex";
		private static final String KEY_LIGHT_IDLE_FACTOR = "light_idle_factor";
		private static final String KEY_LIGHT_IDLE_INCREASE_LINEARLY =
		"light_idle_increase_linearly";
		private static final String KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS =
		"light_idle_linear_increase_factor_ms";
		private static final String KEY_LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS =
		"light_idle_flex_linear_increase_factor_ms";
		private static final String KEY_LIGHT_MAX_IDLE_TIMEOUT = "light_max_idle_to";
		private static final String KEY_LIGHT_IDLE_MAINTENANCE_MIN_BUDGET =
		"light_idle_maintenance_min_budget";
		@@ -1079,6 +1085,10 @@ public class DeviceIdleController extends SystemService
		private long mDefaultLightIdleTimeoutMaxFlex =
		!COMPRESS_TIME ? 15 * 60 * 1000L : 60 * 1000L;
		private float mDefaultLightIdleFactor = 2f;
		private boolean mDefaultLightIdleIncreaseLinearly;
		private long mDefaultLightIdleLinearIncreaseFactorMs = mDefaultLightIdleTimeout;
		private long mDefaultLightIdleFlexLinearIncreaseFactorMs =
		mDefaultLightIdleTimeoutInitialFlex;
		private long mDefaultLightMaxIdleTimeout =
		!COMPRESS_TIME ? 15 * 60 * 1000L : 60 * 1000L;
		private long mDefaultLightIdleMaintenanceMinBudget =
		@@ -1173,6 +1183,37 @@ public class DeviceIdleController extends SystemService
		*/
		public float LIGHT_IDLE_FACTOR = mDefaultLightIdleFactor;

		/**
		* Whether to increase the light idle mode time linearly or exponentially.
		* If true, will increase linearly
		* (i.e. {@link #LIGHT_IDLE_TIMEOUT} + x * {@link #LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS}).
		* If false, will increase by exponentially
		* (i.e. {@link #LIGHT_IDLE_TIMEOUT} * ({@link #LIGHT_IDLE_FACTOR} ^ x)).
		* This will also impact how the light idle flex value
		* ({@link #LIGHT_IDLE_TIMEOUT_INITIAL_FLEX}) is increased (using
		* {@link #LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS} for the linear increase)..
		*
		* @see #KEY_LIGHT_IDLE_INCREASE_LINEARLY
		*/
		public boolean LIGHT_IDLE_INCREASE_LINEARLY = mDefaultLightIdleIncreaseLinearly;

		/**
		* Amount of time to increase the light idle time by, if increasing it linearly.
		*
		* @see #KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS
		* @see #LIGHT_IDLE_INCREASE_LINEARLY
		*/
		public long LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS = mDefaultLightIdleLinearIncreaseFactorMs;

		/**
		* Amount of time to increase the light idle flex time by, if increasing it linearly.
		*
		* @see #KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS
		* @see #LIGHT_IDLE_INCREASE_LINEARLY
		*/
		public long LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS =
		mDefaultLightIdleFlexLinearIncreaseFactorMs;

		/**
		* This is the maximum time we will stay in light idle mode.
		*
		@@ -1409,6 +1450,16 @@ public class DeviceIdleController extends SystemService
		mDefaultLightIdleTimeoutMaxFlex);
		mDefaultLightIdleFactor = res.getFloat(
		com.android.internal.R.integer.device_idle_light_idle_factor);
		mDefaultLightIdleIncreaseLinearly = res.getBoolean(
		com.android.internal.R.bool.device_idle_light_idle_increase_linearly);
		mDefaultLightIdleLinearIncreaseFactorMs = getTimeout(res.getInteger(
		com.android.internal.R.integer
		.device_idle_light_idle_linear_increase_factor_ms),
		mDefaultLightIdleLinearIncreaseFactorMs);
		mDefaultLightIdleFlexLinearIncreaseFactorMs = getTimeout(res.getInteger(
		com.android.internal.R.integer
		.device_idle_light_idle_flex_linear_increase_factor_ms),
		mDefaultLightIdleFlexLinearIncreaseFactorMs);
		mDefaultLightMaxIdleTimeout = getTimeout(
		res.getInteger(com.android.internal.R.integer.device_idle_light_max_idle_to_ms),
		mDefaultLightMaxIdleTimeout);
		@@ -1487,6 +1538,9 @@ public class DeviceIdleController extends SystemService
		LIGHT_IDLE_TIMEOUT_INITIAL_FLEX = mDefaultLightIdleTimeoutInitialFlex;
		LIGHT_IDLE_TIMEOUT_MAX_FLEX = mDefaultLightIdleTimeoutMaxFlex;
		LIGHT_IDLE_FACTOR = mDefaultLightIdleFactor;
		LIGHT_IDLE_INCREASE_LINEARLY = mDefaultLightIdleIncreaseLinearly;
		LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS = mDefaultLightIdleLinearIncreaseFactorMs;
		LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS = mDefaultLightIdleFlexLinearIncreaseFactorMs;
		LIGHT_MAX_IDLE_TIMEOUT = mDefaultLightMaxIdleTimeout;
		LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = mDefaultLightIdleMaintenanceMinBudget;
		LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = mDefaultLightIdleMaintenanceMaxBudget;
		@@ -1556,6 +1610,21 @@ public class DeviceIdleController extends SystemService
		LIGHT_IDLE_FACTOR = Math.max(1, properties.getFloat(
		KEY_LIGHT_IDLE_FACTOR, mDefaultLightIdleFactor));
		break;
		case KEY_LIGHT_IDLE_INCREASE_LINEARLY:
		LIGHT_IDLE_INCREASE_LINEARLY = properties.getBoolean(
		KEY_LIGHT_IDLE_INCREASE_LINEARLY,
		mDefaultLightIdleIncreaseLinearly);
		break;
		case KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS:
		LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS = properties.getLong(
		KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS,
		mDefaultLightIdleLinearIncreaseFactorMs);
		break;
		case KEY_LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS:
		LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS = properties.getLong(
		KEY_LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS,
		mDefaultLightIdleFlexLinearIncreaseFactorMs);
		break;
		case KEY_LIGHT_MAX_IDLE_TIMEOUT:
		LIGHT_MAX_IDLE_TIMEOUT = properties.getLong(
		KEY_LIGHT_MAX_IDLE_TIMEOUT, mDefaultLightMaxIdleTimeout);
		@@ -1716,6 +1785,20 @@ public class DeviceIdleController extends SystemService
		pw.print(LIGHT_IDLE_FACTOR);
		pw.println();

		pw.print(" "); pw.print(KEY_LIGHT_IDLE_INCREASE_LINEARLY); pw.print("=");
		pw.print(LIGHT_IDLE_INCREASE_LINEARLY);
		pw.println();

		pw.print(" "); pw.print(KEY_LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS);
		pw.print("=");
		pw.print(LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS);
		pw.println();

		pw.print(" "); pw.print(KEY_LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS);
		pw.print("=");
		pw.print(LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS);
		pw.println();

		pw.print(" "); pw.print(KEY_LIGHT_MAX_IDLE_TIMEOUT); pw.print("=");
		TimeUtils.formatDuration(LIGHT_MAX_IDLE_TIMEOUT, pw);
		pw.println();
		@@ -3694,10 +3777,18 @@ public class DeviceIdleController extends SystemService
		}
		mMaintenanceStartTime = 0;
		scheduleLightAlarmLocked(mNextLightIdleDelay, mNextLightIdleDelayFlex, true);
		if (!mConstants.LIGHT_IDLE_INCREASE_LINEARLY) {
		mNextLightIdleDelay = Math.min(mConstants.LIGHT_MAX_IDLE_TIMEOUT,
		(long) (mNextLightIdleDelay * mConstants.LIGHT_IDLE_FACTOR));
		mNextLightIdleDelayFlex = Math.min(mConstants.LIGHT_IDLE_TIMEOUT_MAX_FLEX,
		(long) (mNextLightIdleDelayFlex * mConstants.LIGHT_IDLE_FACTOR));
		} else {
		mNextLightIdleDelay = Math.min(mConstants.LIGHT_MAX_IDLE_TIMEOUT,
		mNextLightIdleDelay + mConstants.LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS);
		mNextLightIdleDelayFlex = Math.min(mConstants.LIGHT_IDLE_TIMEOUT_MAX_FLEX,
		mNextLightIdleDelayFlex
		+ mConstants.LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS);
		}
		moveToLightStateLocked(LIGHT_STATE_IDLE, reason);
		addEvent(EVENT_LIGHT_IDLE, null);
		mGoingIdleWakeLock.acquire();

core/res/res/values/config_device_idle.xml

+9 −0

Original line number	Diff line number	Diff line
		@@ -42,6 +42,15 @@
		<!-- Default for DeviceIdleController.Constants.LIGHT_IDLE_FACTOR -->
		<item name="device_idle_light_idle_factor" format="float" type="integer">2.0</item>

		<!-- Default for DeviceIdleController.Constants.LIGHT_IDLE_INCREASE_LINEARLY -->
		<bool name="device_idle_light_idle_increase_linearly">false</bool>

		<!-- Default for DeviceIdleController.Constants.LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS -->
		<integer name="device_idle_light_idle_linear_increase_factor_ms">300000</integer>

		<!-- Default for DeviceIdleController.Constants.LIGHT_IDLE_FLEX_LINEAR_INCREASE_FACTOR_MS -->
		<integer name="device_idle_light_idle_flex_linear_increase_factor_ms">60000</integer>

		<!-- Default for DeviceIdleController.Constants.LIGHT_MAX_IDLE_TIMEOUT -->
		<integer name="device_idle_light_max_idle_to_ms">900000</integer>

core/res/res/values/symbols.xml

+3 −0

Original line number	Diff line number	Diff line
		@@ -4537,7 +4537,10 @@
		<java-symbol type="integer" name="device_idle_light_idle_to_init_flex_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_to_max_flex_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_factor" />
		<java-symbol type="bool" name="device_idle_light_idle_increase_linearly" />
		<java-symbol type="integer" name="device_idle_light_max_idle_to_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_linear_increase_factor_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_flex_linear_increase_factor_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_maintenance_min_budget_ms" />
		<java-symbol type="integer" name="device_idle_light_idle_maintenance_max_budget_ms" />
		<java-symbol type="integer" name="device_idle_min_light_maintenance_time_ms" />

services/tests/mockingservicestests/src/com/android/server/DeviceIdleControllerTest.java

+78 −2

Original line number	Diff line number	Diff line
		@@ -1290,7 +1290,8 @@ public class DeviceIdleControllerTest {
		}

		@Test
		public void testLightStepIdleStateIdlingTimeIncreases() {
		public void testLightStepIdleStateIdlingTimeIncreasesExponentially() {
		mConstants.LIGHT_IDLE_INCREASE_LINEARLY = false;
		final long maintenanceTimeMs = 60_000L;
		mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = maintenanceTimeMs;
		mConstants.LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = maintenanceTimeMs;
		@@ -1335,13 +1336,88 @@ public class DeviceIdleControllerTest {
		eq(mInjector.nowElapsed + idlingTimeMs),
		anyLong(), anyString(), any(), any(Handler.class));

		for (int i = 0; i < 2; ++i) {
		for (int i = 0; i < 10; ++i) {
		// IDLE->MAINTENANCE alarm
		mInjector.nowElapsed = mDeviceIdleController.getNextLightAlarmTimeForTesting();
		alarmListener.onAlarm();
		verifyLightStateConditions(LIGHT_STATE_IDLE_MAINTENANCE);
		long maintenanceExpiryTime = mInjector.nowElapsed + maintenanceTimeMs;
		idlingTimeMs *= mConstants.LIGHT_IDLE_FACTOR;
		idlingTimeMs = Math.min(idlingTimeMs, mConstants.LIGHT_MAX_IDLE_TIMEOUT);
		// Set MAINTENANCE->IDLE
		alarmManagerInOrder.verify(mAlarmManager).setWindow(
		eq(AlarmManager.ELAPSED_REALTIME_WAKEUP),
		eq(maintenanceExpiryTime),
		anyLong(), anyString(), any(), any(Handler.class));

		// MAINTENANCE->IDLE alarm
		mInjector.nowElapsed = mDeviceIdleController.getNextLightAlarmTimeForTesting();
		alarmListener.onAlarm();
		verifyLightStateConditions(LIGHT_STATE_IDLE);
		// Set IDLE->MAINTENANCE again
		alarmManagerInOrder.verify(mAlarmManager).setWindow(
		eq(AlarmManager.ELAPSED_REALTIME_WAKEUP),
		eq(mInjector.nowElapsed + idlingTimeMs),
		anyLong(), anyString(), any(), any(Handler.class));
		}
		}

		@Test
		public void testLightStepIdleStateIdlingTimeIncreasesLinearly() {
		mConstants.LIGHT_IDLE_INCREASE_LINEARLY = true;
		final long maintenanceTimeMs = 60_000L;
		mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET = maintenanceTimeMs;
		mConstants.LIGHT_IDLE_MAINTENANCE_MAX_BUDGET = maintenanceTimeMs;
		mConstants.LIGHT_IDLE_TIMEOUT = 5 * 60_000L;
		mConstants.LIGHT_MAX_IDLE_TIMEOUT = 30 * 60_000L;
		mConstants.LIGHT_IDLE_FACTOR = 2f;
		mConstants.LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS = 2 * 60_000L;

		setNetworkConnected(true);
		mDeviceIdleController.setJobsActive(false);
		mDeviceIdleController.setAlarmsActive(false);
		mDeviceIdleController.setActiveIdleOpsForTest(0);

		InOrder alarmManagerInOrder = inOrder(mAlarmManager);

		final ArgumentCaptor<AlarmManager.OnAlarmListener> alarmListenerCaptor = ArgumentCaptor
		.forClass(AlarmManager.OnAlarmListener.class);
		doNothing().when(mAlarmManager).setWindow(anyInt(), anyLong(), anyLong(),
		eq("DeviceIdleController.light"), alarmListenerCaptor.capture(), any());

		// Set state to INACTIVE.
		mDeviceIdleController.becomeActiveLocked("testing", 0);
		setChargingOn(false);
		setScreenOn(false);
		verifyLightStateConditions(LIGHT_STATE_INACTIVE);
		long idlingTimeMs = mConstants.LIGHT_IDLE_TIMEOUT;
		final long idleAfterInactiveExpiryTime =
		mInjector.nowElapsed + mConstants.LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT;
		alarmManagerInOrder.verify(mAlarmManager).setWindow(
		eq(AlarmManager.ELAPSED_REALTIME_WAKEUP),
		eq(idleAfterInactiveExpiryTime),
		anyLong(), anyString(), any(), any(Handler.class));

		final AlarmManager.OnAlarmListener alarmListener =
		alarmListenerCaptor.getAllValues().get(0);

		// INACTIVE -> IDLE alarm
		mInjector.nowElapsed = mDeviceIdleController.getNextLightAlarmTimeForTesting();
		alarmListener.onAlarm();
		verifyLightStateConditions(LIGHT_STATE_IDLE);
		alarmManagerInOrder.verify(mAlarmManager).setWindow(
		eq(AlarmManager.ELAPSED_REALTIME_WAKEUP),
		eq(mInjector.nowElapsed + idlingTimeMs),
		anyLong(), anyString(), any(), any(Handler.class));

		for (int i = 0; i < 10; ++i) {
		// IDLE->MAINTENANCE alarm
		mInjector.nowElapsed = mDeviceIdleController.getNextLightAlarmTimeForTesting();
		alarmListener.onAlarm();
		verifyLightStateConditions(LIGHT_STATE_IDLE_MAINTENANCE);
		long maintenanceExpiryTime = mInjector.nowElapsed + maintenanceTimeMs;
		idlingTimeMs += mConstants.LIGHT_IDLE_LINEAR_INCREASE_FACTOR_MS;
		idlingTimeMs = Math.min(idlingTimeMs, mConstants.LIGHT_MAX_IDLE_TIMEOUT);
		// Set MAINTENANCE->IDLE
		alarmManagerInOrder.verify(mAlarmManager).setWindow(
		eq(AlarmManager.ELAPSED_REALTIME_WAKEUP),