From b5480ac5833e6b6fb8b6e7ab6fc2c5c8050925bc Mon Sep 17 00:00:00 2001 From: alexbianchi Date: Mon, 22 Aug 2022 19:59:28 +0000 Subject: [PATCH] Decrease number of sElapsedRealtimeClock.millis() calls in Flexibility Controller Getting the current elapsed time is system intensive. Currently flexibility controller gets the elapsed time within for loops and in functions that are called at the same time. By passing in nowElapsed we can decrease the amount of times we call sElapsedRealtimeClock.millis(). Bug: 243166228 Test: atest frameworks/base/services/tests/mockingservicestests/src/com/android/server/job Test: atest frameworks/base/services/tests/servicestests/src/com/android/server/job Test: atest CtsJobSchedulerTestCases Change-Id: I8bed88b97306af0fc7d0beadb43cb252ad0d5afe --- .../job/controllers/BatteryController.java | 11 +- .../controllers/FlexibilityController.java | 41 +++---- .../job/controllers/IdleController.java | 3 +- .../job/controllers/PrefetchController.java | 7 +- .../FlexibilityControllerTest.java | 108 +++++++++++------- .../controllers/PrefetchControllerTest.java | 6 +- 6 files changed, 98 insertions(+), 78 deletions(-) diff --git a/apex/jobscheduler/service/java/com/android/server/job/controllers/BatteryController.java b/apex/jobscheduler/service/java/com/android/server/job/controllers/BatteryController.java index 59cd82e971bf9..3bbc5a3696843 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/controllers/BatteryController.java +++ b/apex/jobscheduler/service/java/com/android/server/job/controllers/BatteryController.java @@ -176,12 +176,13 @@ public final class BatteryController extends RestrictingController { Slog.d(TAG, "maybeReportNewChargingStateLocked: " + powerConnected + "/" + stablePower + "/" + batteryNotLow); } - mFlexibilityController.setConstraintSatisfied( - JobStatus.CONSTRAINT_CHARGING, mService.isBatteryCharging()); - mFlexibilityController - .setConstraintSatisfied(JobStatus.CONSTRAINT_BATTERY_NOT_LOW, batteryNotLow); - final long nowElapsed = sElapsedRealtimeClock.millis(); + + mFlexibilityController.setConstraintSatisfied( + JobStatus.CONSTRAINT_CHARGING, mService.isBatteryCharging(), nowElapsed); + mFlexibilityController.setConstraintSatisfied( + JobStatus.CONSTRAINT_BATTERY_NOT_LOW, batteryNotLow, nowElapsed); + for (int i = mTrackedTasks.size() - 1; i >= 0; i--) { final JobStatus ts = mTrackedTasks.valueAt(i); if (ts.hasChargingConstraint()) { diff --git a/apex/jobscheduler/service/java/com/android/server/job/controllers/FlexibilityController.java b/apex/jobscheduler/service/java/com/android/server/job/controllers/FlexibilityController.java index 2e41dfd2888c8..3ca1ad58955dc 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/controllers/FlexibilityController.java +++ b/apex/jobscheduler/service/java/com/android/server/job/controllers/FlexibilityController.java @@ -137,9 +137,9 @@ public final class FlexibilityController extends StateController { new PrefetchController.PrefetchChangedListener() { @Override public void onPrefetchCacheUpdated(ArraySet jobs, int userId, - String pkgName, long prevEstimatedLaunchTime, long newEstimatedLaunchTime) { + String pkgName, long prevEstimatedLaunchTime, + long newEstimatedLaunchTime, long nowElapsed) { synchronized (mLock) { - final long nowElapsed = sElapsedRealtimeClock.millis(); final long prefetchThreshold = mPrefetchController.getLaunchTimeThresholdMs(); boolean jobWasInPrefetchWindow = prevEstimatedLaunchTime @@ -158,8 +158,8 @@ public final class FlexibilityController extends StateController { if (!js.hasFlexibilityConstraint()) { continue; } - mFlexibilityTracker.resetJobNumDroppedConstraints(js); - mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js); + mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); + mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js, nowElapsed); } } } @@ -191,7 +191,7 @@ public final class FlexibilityController extends StateController { js.setTrackingController(JobStatus.TRACKING_FLEXIBILITY); final long nowElapsed = sElapsedRealtimeClock.millis(); js.setFlexibilityConstraintSatisfied(nowElapsed, isFlexibilitySatisfiedLocked(js)); - mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js); + mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js, nowElapsed); } } @@ -239,7 +239,7 @@ public final class FlexibilityController extends StateController { * Changes flexibility constraint satisfaction for affected jobs. */ @VisibleForTesting - void setConstraintSatisfied(int constraint, boolean state) { + void setConstraintSatisfied(int constraint, boolean state, long nowElapsed) { synchronized (mLock) { final boolean old = (mSatisfiedFlexibleConstraints & constraint) != 0; if (old == state) { @@ -255,8 +255,6 @@ public final class FlexibilityController extends StateController { // The rest did not have a change in state and are still satisfied or unsatisfied. final int numConstraintsToUpdate = Math.max(curSatisfied, prevSatisfied); - final long nowElapsed = sElapsedRealtimeClock.millis(); - // In order to get the range of all potentially satisfied jobs, we start at the number // of satisfied system-wide constraints and iterate to the max number of potentially // satisfied constraints, determined by how many job-specific constraints exist. @@ -329,10 +327,9 @@ public final class FlexibilityController extends StateController { @VisibleForTesting @GuardedBy("mLock") - int getCurPercentOfLifecycleLocked(JobStatus js) { + int getCurPercentOfLifecycleLocked(JobStatus js, long nowElapsed) { final long earliest = getLifeCycleBeginningElapsedLocked(js); final long latest = getLifeCycleEndElapsedLocked(js, earliest); - final long nowElapsed = sElapsedRealtimeClock.millis(); if (latest == NO_LIFECYCLE_END || earliest >= nowElapsed) { return 0; } @@ -414,8 +411,8 @@ public final class FlexibilityController extends StateController { .getJobsByNumRequiredConstraints(j); for (int i = 0; i < jobs.size(); i++) { JobStatus js = jobs.valueAt(i); - mFlexibilityTracker.resetJobNumDroppedConstraints(js); - mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js); + mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); + mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js, nowElapsed); if (js.setFlexibilityConstraintSatisfied( nowElapsed, isFlexibilitySatisfiedLocked(js))) { changedJobs.add(js); @@ -479,8 +476,8 @@ public final class FlexibilityController extends StateController { mTrackedJobs.get(js.getNumRequiredFlexibleConstraints() - 1).remove(js); } - public void resetJobNumDroppedConstraints(JobStatus js) { - final int curPercent = getCurPercentOfLifecycleLocked(js); + public void resetJobNumDroppedConstraints(JobStatus js, long nowElapsed) { + final int curPercent = getCurPercentOfLifecycleLocked(js, nowElapsed); int toDrop = 0; final int jsMaxFlexibleConstraints = NUM_SYSTEM_WIDE_FLEXIBLE_CONSTRAINTS + (js.getPreferUnmetered() ? 1 : 0); @@ -489,7 +486,8 @@ public final class FlexibilityController extends StateController { toDrop++; } } - adjustJobsRequiredConstraints(js, js.getNumDroppedFlexibleConstraints() - toDrop); + adjustJobsRequiredConstraints( + js, js.getNumDroppedFlexibleConstraints() - toDrop, nowElapsed); } /** Returns all tracked jobs. */ @@ -502,13 +500,12 @@ public final class FlexibilityController extends StateController { * Returns false if the job status's number of flexible constraints is now 0. * Jobs with 0 required flexible constraints are removed from the tracker. */ - public boolean adjustJobsRequiredConstraints(JobStatus js, int n) { + public boolean adjustJobsRequiredConstraints(JobStatus js, int n, long nowElapsed) { if (n == 0) { return false; } remove(js); js.adjustNumRequiredFlexibleConstraints(n); - final long nowElapsed = sElapsedRealtimeClock.millis(); js.setFlexibilityConstraintSatisfied(nowElapsed, isFlexibilitySatisfiedLocked(js)); if (js.getNumRequiredFlexibleConstraints() <= 0) { maybeStopTrackingJobLocked(js, null, false); @@ -553,7 +550,7 @@ public final class FlexibilityController extends StateController { return js.getSourceUserId() == userId; } - public void scheduleDropNumConstraintsAlarm(JobStatus js) { + public void scheduleDropNumConstraintsAlarm(JobStatus js, long nowElapsed) { long nextTimeElapsed; synchronized (mLock) { final long earliest = getLifeCycleBeginningElapsedLocked(js); @@ -567,7 +564,7 @@ public final class FlexibilityController extends StateController { if (latest - nextTimeElapsed < mDeadlineProximityLimitMs) { mFlexibilityTracker.adjustJobsRequiredConstraints( - js, -js.getNumRequiredFlexibleConstraints()); + js, -js.getNumRequiredFlexibleConstraints(), nowElapsed); return; } addAlarm(js, nextTimeElapsed); @@ -578,21 +575,21 @@ public final class FlexibilityController extends StateController { protected void processExpiredAlarms(@NonNull ArraySet expired) { synchronized (mLock) { ArraySet changedJobs = new ArraySet<>(); + final long nowElapsed = sElapsedRealtimeClock.millis(); for (int i = 0; i < expired.size(); i++) { JobStatus js = expired.valueAt(i); boolean wasFlexibilitySatisfied = js.isConstraintSatisfied(CONSTRAINT_FLEXIBLE); final long earliest = getLifeCycleBeginningElapsedLocked(js); final long latest = getLifeCycleEndElapsedLocked(js, earliest); - final long nowElapsed = sElapsedRealtimeClock.millis(); if (latest - nowElapsed < mDeadlineProximityLimitMs) { mFlexibilityTracker.adjustJobsRequiredConstraints(js, - -js.getNumRequiredFlexibleConstraints()); + -js.getNumRequiredFlexibleConstraints(), nowElapsed); } else { long nextTimeElapsed = getNextConstraintDropTimeElapsedLocked(js, earliest, latest); - if (mFlexibilityTracker.adjustJobsRequiredConstraints(js, -1) + if (mFlexibilityTracker.adjustJobsRequiredConstraints(js, -1, nowElapsed) && nextTimeElapsed != NO_LIFECYCLE_END) { mFlexibilityAlarmQueue.addAlarm(js, nextTimeElapsed); } diff --git a/apex/jobscheduler/service/java/com/android/server/job/controllers/IdleController.java b/apex/jobscheduler/service/java/com/android/server/job/controllers/IdleController.java index d5750f8d7974a..dd06217287249 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/controllers/IdleController.java +++ b/apex/jobscheduler/service/java/com/android/server/job/controllers/IdleController.java @@ -95,9 +95,10 @@ public final class IdleController extends RestrictingController implements Idlen */ @Override public void reportNewIdleState(boolean isIdle) { - mFlexibilityController.setConstraintSatisfied(JobStatus.CONSTRAINT_IDLE, isIdle); synchronized (mLock) { final long nowElapsed = sElapsedRealtimeClock.millis(); + mFlexibilityController.setConstraintSatisfied( + JobStatus.CONSTRAINT_IDLE, isIdle, nowElapsed); for (int i = mTrackedTasks.size()-1; i >= 0; i--) { mTrackedTasks.valueAt(i).setIdleConstraintSatisfied(nowElapsed, isIdle); } diff --git a/apex/jobscheduler/service/java/com/android/server/job/controllers/PrefetchController.java b/apex/jobscheduler/service/java/com/android/server/job/controllers/PrefetchController.java index 0945b7e796fdd..e04cec30d26b2 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/controllers/PrefetchController.java +++ b/apex/jobscheduler/service/java/com/android/server/job/controllers/PrefetchController.java @@ -105,7 +105,7 @@ public class PrefetchController extends StateController { public interface PrefetchChangedListener { /** Callback to inform listeners when estimated launch times change. */ void onPrefetchCacheUpdated(ArraySet jobs, int userId, String pkgName, - long prevEstimatedLaunchTime, long newEstimatedLaunchTime); + long prevEstimatedLaunchTime, long newEstimatedLaunchTime, long nowElapsed); } @SuppressWarnings("FieldCanBeLocal") @@ -308,8 +308,9 @@ public class PrefetchController extends StateController { final long nowElapsed = sElapsedRealtimeClock.millis(); updateThresholdAlarmLocked(userId, pkgName, now, nowElapsed); for (int i = 0; i < mPrefetchChangedListeners.size(); i++) { - mPrefetchChangedListeners.valueAt(i).onPrefetchCacheUpdated(jobs, - userId, pkgName, prevEstimatedLaunchTime, newEstimatedLaunchTime); + mPrefetchChangedListeners.valueAt(i).onPrefetchCacheUpdated( + jobs, userId, pkgName, prevEstimatedLaunchTime, + newEstimatedLaunchTime, nowElapsed); } if (maybeUpdateConstraintForPkgLocked(now, nowElapsed, userId, pkgName)) { mStateChangedListener.onControllerStateChanged(jobs); diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java index 1b39add3b4210..9d039bd09a2fc 100644 --- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/FlexibilityControllerTest.java @@ -209,7 +209,8 @@ public class FlexibilityControllerTest { public void testOnConstantsUpdated_DeadlineProximity() { JobStatus js = createJobStatus("testDeadlineProximityConfig", createJob(0)); setDeviceConfigLong(KEY_DEADLINE_PROXIMITY_LIMIT, Long.MAX_VALUE); - mFlexibilityController.mFlexibilityAlarmQueue.scheduleDropNumConstraintsAlarm(js); + mFlexibilityController.mFlexibilityAlarmQueue + .scheduleDropNumConstraintsAlarm(js, FROZEN_TIME); assertEquals(0, js.getNumRequiredFlexibleConstraints()); } @@ -336,26 +337,31 @@ public class FlexibilityControllerTest { @Test public void testCurPercent() { long deadline = 1000; + long nowElapsed; JobInfo.Builder jb = createJob(0).setOverrideDeadline(deadline); JobStatus js = createJobStatus("time", jb); assertEquals(FROZEN_TIME, mFlexibilityController.getLifeCycleBeginningElapsedLocked(js)); assertEquals(deadline + FROZEN_TIME, mFlexibilityController.getLifeCycleEndElapsedLocked(js, FROZEN_TIME)); + nowElapsed = 600 + FROZEN_TIME; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(600 + FROZEN_TIME), ZoneOffset.UTC); - assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); + nowElapsed = 1400; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(1400), ZoneOffset.UTC); - assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); + nowElapsed = 950 + FROZEN_TIME; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(950 + FROZEN_TIME), ZoneOffset.UTC); - assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); + nowElapsed = FROZEN_TIME; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(FROZEN_TIME), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); long delay = 100; deadline = 1100; jb = createJob(0).setOverrideDeadline(deadline).setMinimumLatency(delay); @@ -366,18 +372,21 @@ public class FlexibilityControllerTest { assertEquals(deadline + FROZEN_TIME, mFlexibilityController.getLifeCycleEndElapsedLocked(js, FROZEN_TIME + delay)); + nowElapsed = 600 + FROZEN_TIME + delay; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(600 + FROZEN_TIME + delay), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + assertEquals(60, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); + nowElapsed = 1400; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(1400), ZoneOffset.UTC); - assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + assertEquals(100, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); + nowElapsed = 950 + FROZEN_TIME + delay; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(950 + FROZEN_TIME + delay), ZoneOffset.UTC); - assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + assertEquals(95, mFlexibilityController.getCurPercentOfLifecycleLocked(js, nowElapsed)); } @Test @@ -491,19 +500,19 @@ public class FlexibilityControllerTest { assertEquals(3, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); - flexTracker.adjustJobsRequiredConstraints(jobs[0], -1); + flexTracker.adjustJobsRequiredConstraints(jobs[0], -1, FROZEN_TIME); assertEquals(0, trackedJobs.get(0).size()); assertEquals(1, trackedJobs.get(1).size()); assertEquals(2, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); - flexTracker.adjustJobsRequiredConstraints(jobs[0], -1); + flexTracker.adjustJobsRequiredConstraints(jobs[0], -1, FROZEN_TIME); assertEquals(1, trackedJobs.get(0).size()); assertEquals(0, trackedJobs.get(1).size()); assertEquals(2, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); - flexTracker.adjustJobsRequiredConstraints(jobs[0], -1); + flexTracker.adjustJobsRequiredConstraints(jobs[0], -1, FROZEN_TIME); assertEquals(0, trackedJobs.get(0).size()); assertEquals(0, trackedJobs.get(1).size()); assertEquals(2, trackedJobs.get(2).size()); @@ -515,24 +524,25 @@ public class FlexibilityControllerTest { assertEquals(1, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); - flexTracker.resetJobNumDroppedConstraints(jobs[0]); + flexTracker.resetJobNumDroppedConstraints(jobs[0], FROZEN_TIME); assertEquals(0, trackedJobs.get(0).size()); assertEquals(0, trackedJobs.get(1).size()); assertEquals(2, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); - flexTracker.adjustJobsRequiredConstraints(jobs[0], -2); + flexTracker.adjustJobsRequiredConstraints(jobs[0], -2, FROZEN_TIME); assertEquals(1, trackedJobs.get(0).size()); assertEquals(0, trackedJobs.get(1).size()); assertEquals(1, trackedJobs.get(2).size()); assertEquals(0, trackedJobs.get(3).size()); + final long nowElapsed = ((DEFAULT_FALLBACK_FLEXIBILITY_DEADLINE_MS / 2) + + HOUR_IN_MILLIS); JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli((DEFAULT_FALLBACK_FLEXIBILITY_DEADLINE_MS / 2) - + HOUR_IN_MILLIS), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - flexTracker.resetJobNumDroppedConstraints(jobs[0]); + flexTracker.resetJobNumDroppedConstraints(jobs[0], nowElapsed); assertEquals(0, trackedJobs.get(0).size()); assertEquals(1, trackedJobs.get(1).size()); assertEquals(1, trackedJobs.get(2).size()); @@ -615,13 +625,13 @@ public class FlexibilityControllerTest { @Test public void testSetConstraintSatisfied_Constraints() { - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false); + mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false, FROZEN_TIME); assertFalse(mFlexibilityController.isConstraintSatisfied(CONSTRAINT_IDLE)); - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, true); + mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, true, FROZEN_TIME); assertTrue(mFlexibilityController.isConstraintSatisfied(CONSTRAINT_IDLE)); - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false); + mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false, FROZEN_TIME); assertFalse(mFlexibilityController.isConstraintSatisfied(CONSTRAINT_IDLE)); } @@ -651,20 +661,21 @@ public class FlexibilityControllerTest { createJobStatus(String.valueOf(i), jb), null); } } - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_CHARGING, false); - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false); - mFlexibilityController.setConstraintSatisfied(CONSTRAINT_BATTERY_NOT_LOW, false); + mFlexibilityController.setConstraintSatisfied(CONSTRAINT_CHARGING, false, FROZEN_TIME); + mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, false, FROZEN_TIME); + mFlexibilityController.setConstraintSatisfied( + CONSTRAINT_BATTERY_NOT_LOW, false, FROZEN_TIME); assertEquals(0, mFlexibilityController.mSatisfiedFlexibleConstraints); for (int i = 0; i < constraintCombinations.length; i++) { constraints = constraintCombinations[i]; mFlexibilityController.setConstraintSatisfied(CONSTRAINT_CHARGING, - (constraints & CONSTRAINT_CHARGING) != 0); + (constraints & CONSTRAINT_CHARGING) != 0, FROZEN_TIME); mFlexibilityController.setConstraintSatisfied(CONSTRAINT_IDLE, - (constraints & CONSTRAINT_IDLE) != 0); + (constraints & CONSTRAINT_IDLE) != 0, FROZEN_TIME); mFlexibilityController.setConstraintSatisfied(CONSTRAINT_BATTERY_NOT_LOW, - (constraints & CONSTRAINT_BATTERY_NOT_LOW) != 0); + (constraints & CONSTRAINT_BATTERY_NOT_LOW) != 0, FROZEN_TIME); assertEquals(constraints, mFlexibilityController.mSatisfiedFlexibleConstraints); synchronized (mFlexibilityController.mLock) { @@ -679,6 +690,7 @@ public class FlexibilityControllerTest { JobInfo.Builder jb = createJob(22).setOverrideDeadline(100L); JobStatus js = createJobStatus("testResetJobNumDroppedConstraints", jb); js.adjustNumRequiredFlexibleConstraints(3); + long nowElapsed; mFlexibilityController.mFlexibilityTracker.add(js); @@ -687,45 +699,51 @@ public class FlexibilityControllerTest { assertEquals(1, mFlexibilityController .mFlexibilityTracker.getJobsByNumRequiredConstraints(3).size()); - JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(155L), ZoneOffset.UTC); - mFlexibilityController.mFlexibilityTracker.adjustJobsRequiredConstraints(js, -1); + nowElapsed = 155L; + JobSchedulerService.sElapsedRealtimeClock = + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); + + mFlexibilityController.mFlexibilityTracker + .adjustJobsRequiredConstraints(js, -1, nowElapsed); assertEquals(2, js.getNumRequiredFlexibleConstraints()); assertEquals(1, js.getNumDroppedFlexibleConstraints()); assertEquals(1, mFlexibilityController .mFlexibilityTracker.getJobsByNumRequiredConstraints(2).size()); - mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js); + mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); assertEquals(2, js.getNumRequiredFlexibleConstraints()); assertEquals(1, js.getNumDroppedFlexibleConstraints()); assertEquals(1, mFlexibilityController .mFlexibilityTracker.getJobsByNumRequiredConstraints(2).size()); + nowElapsed = 140L; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(140L), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js); + mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); assertEquals(3, js.getNumRequiredFlexibleConstraints()); assertEquals(0, js.getNumDroppedFlexibleConstraints()); assertEquals(1, mFlexibilityController .mFlexibilityTracker.getJobsByNumRequiredConstraints(3).size()); + nowElapsed = 175L; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(175), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js); + mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); assertEquals(0, js.getNumRequiredFlexibleConstraints()); assertEquals(3, js.getNumDroppedFlexibleConstraints()); + nowElapsed = 165L; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(165L), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); - mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js); + mFlexibilityController.mFlexibilityTracker.resetJobNumDroppedConstraints(js, nowElapsed); assertEquals(1, js.getNumRequiredFlexibleConstraints()); assertEquals(2, js.getNumDroppedFlexibleConstraints()); @@ -745,12 +763,14 @@ public class FlexibilityControllerTest { mFlexibilityController.maybeStartTrackingJobLocked(js, null); + final long nowElapsed = 150L; JobSchedulerService.sElapsedRealtimeClock = - Clock.fixed(Instant.ofEpochMilli(150L), ZoneOffset.UTC); + Clock.fixed(Instant.ofEpochMilli(nowElapsed), ZoneOffset.UTC); mFlexibilityController.mPrefetchChangedListener.onPrefetchCacheUpdated( jobs, js.getUserId(), js.getSourcePackageName(), Long.MAX_VALUE, - 1150L + mFlexibilityController.mConstants.PREFETCH_FORCE_BATCH_RELAX_THRESHOLD_MS); + 1150L + mFlexibilityController.mConstants.PREFETCH_FORCE_BATCH_RELAX_THRESHOLD_MS, + nowElapsed); assertEquals(150L, (long) mFlexibilityController.mPrefetchLifeCycleStart @@ -758,7 +778,7 @@ public class FlexibilityControllerTest { assertEquals(150L, mFlexibilityController.getLifeCycleBeginningElapsedLocked(js)); assertEquals(1150L, mFlexibilityController.getLifeCycleEndElapsedLocked(js, 150L)); - assertEquals(0, mFlexibilityController.getCurPercentOfLifecycleLocked(js)); + assertEquals(0, mFlexibilityController.getCurPercentOfLifecycleLocked(js, FROZEN_TIME)); assertEquals(650L, mFlexibilityController .getNextConstraintDropTimeElapsedLocked(js)); assertEquals(3, js.getNumRequiredFlexibleConstraints()); diff --git a/services/tests/mockingservicestests/src/com/android/server/job/controllers/PrefetchControllerTest.java b/services/tests/mockingservicestests/src/com/android/server/job/controllers/PrefetchControllerTest.java index 7242b1bf1ccba..a69d018b9e06e 100644 --- a/services/tests/mockingservicestests/src/com/android/server/job/controllers/PrefetchControllerTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/job/controllers/PrefetchControllerTest.java @@ -491,9 +491,9 @@ public class PrefetchControllerTest { final PrefetchController.PrefetchChangedListener prefetchChangedListener = new PrefetchController.PrefetchChangedListener() { @Override - public void onPrefetchCacheUpdated( - ArraySet jobs, int userId, String pkgName, - long prevEstimatedLaunchTime, long newEstimatedLaunchTime) { + public void onPrefetchCacheUpdated(ArraySet jobs, + int userId, String pkgName, long prevEstimatedLaunchTime, + long newEstimatedLaunchTime, long nowElapsed) { onPrefetchCacheChangedCalled[0] = true; } };