From 485b5c37a37bb95361a1d34c99848214dadca4e8 Mon Sep 17 00:00:00 2001 From: Kweku Adams Date: Thu, 28 Jan 2021 14:32:09 -0800 Subject: [PATCH] Move screen off adjustment delay to JobConcurrencyManager. First step in refactoring the concurrency code. Moving this constant over to JCM since it's a small unit that won't be changed and it's only used by JCM. Bug: 141645789 Bug: 171305774 Bug: 178119369 Test: atest CtsJobSchedulerTestCases Test: atest FrameworksMockingServicesTests:JobSchedulerServiceTest Test: atest FrameworksServicesTests:JobCountTrackerTest Test: atest FrameworksServicesTests:MaxJobCountsTest Test: atest FrameworksServicesTests:PrioritySchedulingTest Change-Id: I2bc3646901fb8d11ec5818ab10fa6653cfd2e684 --- .../server/job/JobConcurrencyManager.java | 31 +++++++++++++---- .../server/job/JobSchedulerService.java | 33 +++---------------- 2 files changed, 28 insertions(+), 36 deletions(-) diff --git a/apex/jobscheduler/service/java/com/android/server/job/JobConcurrencyManager.java b/apex/jobscheduler/service/java/com/android/server/job/JobConcurrencyManager.java index dba1d4b0a2e2f..7cad4ab0183da 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/JobConcurrencyManager.java +++ b/apex/jobscheduler/service/java/com/android/server/job/JobConcurrencyManager.java @@ -25,6 +25,7 @@ import android.content.IntentFilter; import android.os.Handler; import android.os.PowerManager; import android.os.RemoteException; +import android.provider.DeviceConfig; import android.util.IndentingPrintWriter; import android.util.Slog; import android.util.TimeUtils; @@ -35,7 +36,6 @@ import com.android.internal.annotations.VisibleForTesting; import com.android.internal.app.procstats.ProcessStats; import com.android.internal.util.StatLogger; import com.android.server.JobSchedulerBackgroundThread; -import com.android.server.job.JobSchedulerService.Constants; import com.android.server.job.JobSchedulerService.MaxJobCountsPerMemoryTrimLevel; import com.android.server.job.controllers.JobStatus; import com.android.server.job.controllers.StateController; @@ -51,6 +51,11 @@ class JobConcurrencyManager { private static final String TAG = JobSchedulerService.TAG; private static final boolean DEBUG = JobSchedulerService.DEBUG; + static final String CONFIG_KEY_PREFIX_CONCURRENCY = "concurrency_"; + private static final String KEY_SCREEN_OFF_ADJUSTMENT_DELAY_MS = + CONFIG_KEY_PREFIX_CONCURRENCY + "screen_off_adjustment_delay_ms"; + private static final long DEFAULT_SCREEN_OFF_ADJUSTMENT_DELAY_MS = 30_000; + private final Object mLock; private final JobSchedulerService mService; private final JobSchedulerService.Constants mConstants; @@ -84,6 +89,9 @@ class JobConcurrencyManager { private final JobCountTracker mJobCountTracker = new JobCountTracker(); + /** Wait for this long after screen off before adjusting the job concurrency. */ + private long mScreenOffAdjustmentDelayMs = DEFAULT_SCREEN_OFF_ADJUSTMENT_DELAY_MS; + /** Current memory trim level. */ private int mLastMemoryTrimLevel; @@ -165,8 +173,7 @@ class JobConcurrencyManager { // Note: we can't directly do postDelayed(this::rampUpForScreenOn), because // we need the exact same instance for removeCallbacks(). - mHandler.postDelayed(mRampUpForScreenOff, - mConstants.SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS); + mHandler.postDelayed(mRampUpForScreenOff, mScreenOffAdjustmentDelayMs); } } } @@ -174,7 +181,7 @@ class JobConcurrencyManager { private final Runnable mRampUpForScreenOff = this::rampUpForScreenOff; /** - * Called in {@link Constants#SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS} after + * Called in {@link #mScreenOffAdjustmentDelayMs} after * the screen turns off, in order to increase concurrency. */ private void rampUpForScreenOff() { @@ -188,9 +195,7 @@ class JobConcurrencyManager { return; } final long now = JobSchedulerService.sElapsedRealtimeClock.millis(); - if ((mLastScreenOffRealtime - + mConstants.SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS) - > now) { + if ((mLastScreenOffRealtime + mScreenOffAdjustmentDelayMs) > now) { return; } @@ -473,12 +478,24 @@ class JobConcurrencyManager { return s.toString(); } + void updateConfigLocked() { + DeviceConfig.Properties properties = + DeviceConfig.getProperties(DeviceConfig.NAMESPACE_JOB_SCHEDULER); + + mScreenOffAdjustmentDelayMs = properties.getLong( + KEY_SCREEN_OFF_ADJUSTMENT_DELAY_MS, DEFAULT_SCREEN_OFF_ADJUSTMENT_DELAY_MS); + } public void dumpLocked(IndentingPrintWriter pw, long now, long nowRealtime) { pw.println("Concurrency:"); pw.increaseIndent(); try { + pw.print("Configuration:"); + pw.increaseIndent(); + pw.print(KEY_SCREEN_OFF_ADJUSTMENT_DELAY_MS, mScreenOffAdjustmentDelayMs).println(); + pw.decreaseIndent(); + pw.print("Screen state: current "); pw.print(mCurrentInteractiveState ? "ON" : "OFF"); pw.print(" effective "); diff --git a/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java b/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java index 97ba815d935c6..885662c241474 100644 --- a/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java +++ b/apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java @@ -369,12 +369,6 @@ public class JobSchedulerService extends com.android.server.SystemService case Constants.KEY_MODERATE_USE_FACTOR: mConstants.updateUseFactorConstantsLocked(); break; - case Constants.KEY_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS: - if (!concurrencyUpdated) { - mConstants.updateConcurrencyConstantsLocked(); - concurrencyUpdated = true; - } - break; case Constants.KEY_MIN_LINEAR_BACKOFF_TIME_MS: case Constants.KEY_MIN_EXP_BACKOFF_TIME_MS: mConstants.updateBackoffConstantsLocked(); @@ -384,10 +378,10 @@ public class JobSchedulerService extends com.android.server.SystemService mConstants.updateConnectivityConstantsLocked(); break; default: - // Too many max_job_* strings to list. - if (name.startsWith(Constants.KEY_PREFIX_MAX_JOB) + if (name.startsWith(JobConcurrencyManager.CONFIG_KEY_PREFIX_CONCURRENCY) && !concurrencyUpdated) { mConstants.updateConcurrencyConstantsLocked(); + mConcurrencyManager.updateConfigLocked(); concurrencyUpdated = true; } else { for (int ctrlr = 0; ctrlr < mControllers.size(); ctrlr++) { @@ -552,9 +546,6 @@ public class JobSchedulerService extends com.android.server.SystemService private static final String KEY_API_QUOTA_SCHEDULE_RETURN_FAILURE_RESULT = "aq_schedule_return_failure"; - private static final String KEY_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS = - "screen_off_job_concurrency_increase_delay_ms"; - private static final int DEFAULT_MIN_READY_NON_ACTIVE_JOBS_COUNT = 5; private static final long DEFAULT_MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS = 31 * MINUTE_IN_MILLIS; private static final float DEFAULT_HEAVY_USE_FACTOR = .9f; @@ -568,7 +559,6 @@ public class JobSchedulerService extends com.android.server.SystemService private static final long DEFAULT_API_QUOTA_SCHEDULE_WINDOW_MS = MINUTE_IN_MILLIS; private static final boolean DEFAULT_API_QUOTA_SCHEDULE_THROW_EXCEPTION = true; private static final boolean DEFAULT_API_QUOTA_SCHEDULE_RETURN_FAILURE_RESULT = false; - private static final long DEFAULT_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS = 30_000; /** * Minimum # of non-ACTIVE jobs for which the JMS will be happy running some work early. @@ -591,7 +581,8 @@ public class JobSchedulerService extends com.android.server.SystemService float MODERATE_USE_FACTOR = DEFAULT_MODERATE_USE_FACTOR; /** Prefix for all of the max_job constants. */ - private static final String KEY_PREFIX_MAX_JOB = "max_job_"; + private static final String KEY_PREFIX_MAX_JOB = + JobConcurrencyManager.CONFIG_KEY_PREFIX_CONCURRENCY + "max_job_"; // Max job counts for screen on / off, for each memory trim level. final MaxJobCountsPerMemoryTrimLevel MAX_JOB_COUNTS_SCREEN_ON = @@ -632,11 +623,6 @@ public class JobSchedulerService extends com.android.server.SystemService 1, KEY_PREFIX_MAX_JOB + "max_bg_off_critical", 1, KEY_PREFIX_MAX_JOB + "min_bg_off_critical")); - - /** Wait for this long after screen off before increasing the job concurrency. */ - long SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS = - DEFAULT_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS; - /** * The minimum backoff time to allow for linear backoff. */ @@ -710,11 +696,6 @@ public class JobSchedulerService extends com.android.server.SystemService MAX_JOB_COUNTS_SCREEN_OFF.moderate.update(); MAX_JOB_COUNTS_SCREEN_OFF.low.update(); MAX_JOB_COUNTS_SCREEN_OFF.critical.update(); - - SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS = DeviceConfig.getLong( - DeviceConfig.NAMESPACE_JOB_SCHEDULER, - KEY_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS, - DEFAULT_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS); } private void updateBackoffConstantsLocked() { @@ -776,9 +757,6 @@ public class JobSchedulerService extends com.android.server.SystemService MAX_JOB_COUNTS_SCREEN_OFF.low.dump(pw, ""); MAX_JOB_COUNTS_SCREEN_OFF.critical.dump(pw, ""); - pw.print(KEY_SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS, - SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS).println(); - pw.print(KEY_MIN_LINEAR_BACKOFF_TIME_MS, MIN_LINEAR_BACKOFF_TIME_MS).println(); pw.print(KEY_MIN_EXP_BACKOFF_TIME_MS, MIN_EXP_BACKOFF_TIME_MS).println(); pw.print(KEY_CONN_CONGESTION_DELAY_FRAC, CONN_CONGESTION_DELAY_FRAC).println(); @@ -806,9 +784,6 @@ public class JobSchedulerService extends com.android.server.SystemService MAX_JOB_COUNTS_SCREEN_ON.dumpProto(proto, ConstantsProto.MAX_JOB_COUNTS_SCREEN_ON); MAX_JOB_COUNTS_SCREEN_OFF.dumpProto(proto, ConstantsProto.MAX_JOB_COUNTS_SCREEN_OFF); - proto.write(ConstantsProto.SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS, - SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS); - proto.write(ConstantsProto.MIN_LINEAR_BACKOFF_TIME_MS, MIN_LINEAR_BACKOFF_TIME_MS); proto.write(ConstantsProto.MIN_EXP_BACKOFF_TIME_MS, MIN_EXP_BACKOFF_TIME_MS); proto.write(ConstantsProto.CONN_CONGESTION_DELAY_FRAC, CONN_CONGESTION_DELAY_FRAC);