Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Removing unused flags.

Browse Source 
We thought about batching based on constraints when JobScheduler was
first introduced (in Lollipop) but immediately disabled that behavior.
We haven't used the flags since then, and now that we're batching all
jobs that aren't in the ACTIVE bucket, these extra flags are not needed.

Bug: 141645789
Test: atest FrameworksMockingServicesTests:JobSchedulerServiceTest
Test: atest CtsIncidentHostTestCases:JobSchedulerIncidentTest
Change-Id: I8df75007a0c8124ea35c7917a5413310fbdeff79
This commit is contained in:
Kweku Adams
2020-02-11 12:06:26 -08:00
parent 004e36da64
commit 111b8221ff
3 changed files with 38 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

162
apex/jobscheduler/service/java/com/android/server/job/JobSchedulerService.java
View File

@@ -473,13 +473,17 @@ public class JobSchedulerService extends com.android.server.SystemService
*/
public static class Constants {
// Key names stored in the settings value.
private static final String KEY_MIN_IDLE_COUNT = "min_idle_count";
private static final String KEY_MIN_CHARGING_COUNT = "min_charging_count";
private static final String KEY_MIN_BATTERY_NOT_LOW_COUNT = "min_battery_not_low_count";
private static final String KEY_MIN_STORAGE_NOT_LOW_COUNT = "min_storage_not_low_count";
private static final String KEY_MIN_CONNECTIVITY_COUNT = "min_connectivity_count";
private static final String KEY_MIN_CONTENT_COUNT = "min_content_count";
private static final String KEY_MIN_READY_JOBS_COUNT = "min_ready_jobs_count";
// TODO(124466289): remove deprecated flags when we migrate to DeviceConfig
private static final String DEPRECATED_KEY_MIN_IDLE_COUNT = "min_idle_count";
private static final String DEPRECATED_KEY_MIN_CHARGING_COUNT = "min_charging_count";
private static final String DEPRECATED_KEY_MIN_BATTERY_NOT_LOW_COUNT =
"min_battery_not_low_count";
private static final String DEPRECATED_KEY_MIN_STORAGE_NOT_LOW_COUNT =
"min_storage_not_low_count";
private static final String DEPRECATED_KEY_MIN_CONNECTIVITY_COUNT =
"min_connectivity_count";
private static final String DEPRECATED_KEY_MIN_CONTENT_COUNT = "min_content_count";
private static final String DEPRECATED_KEY_MIN_READY_JOBS_COUNT = "min_ready_jobs_count";
private static final String KEY_MIN_READY_NON_ACTIVE_JOBS_COUNT =
"min_ready_non_active_jobs_count";
private static final String KEY_MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS =
@@ -515,13 +519,6 @@ public class JobSchedulerService extends com.android.server.SystemService
private static final String KEY_API_QUOTA_SCHEDULE_THROW_EXCEPTION =
"aq_schedule_throw_exception";
private static final int DEFAULT_MIN_IDLE_COUNT = 1;
private static final int DEFAULT_MIN_CHARGING_COUNT = 1;
private static final int DEFAULT_MIN_BATTERY_NOT_LOW_COUNT = 1;
private static final int DEFAULT_MIN_STORAGE_NOT_LOW_COUNT = 1;
private static final int DEFAULT_MIN_CONNECTIVITY_COUNT = 1;
private static final int DEFAULT_MIN_CONTENT_COUNT = 1;
private static final int DEFAULT_MIN_READY_JOBS_COUNT = 1;
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;
@@ -535,44 +532,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;
/**
* Minimum # of idle jobs that must be ready in order to force the JMS to schedule things
* early.
*/
int MIN_IDLE_COUNT = DEFAULT_MIN_IDLE_COUNT;
/**
* Minimum # of charging jobs that must be ready in order to force the JMS to schedule
* things early.
*/
int MIN_CHARGING_COUNT = DEFAULT_MIN_CHARGING_COUNT;
/**
* Minimum # of "battery not low" jobs that must be ready in order to force the JMS to
* schedule things early.
*/
int MIN_BATTERY_NOT_LOW_COUNT = DEFAULT_MIN_BATTERY_NOT_LOW_COUNT;
/**
* Minimum # of "storage not low" jobs that must be ready in order to force the JMS to
* schedule things early.
*/
int MIN_STORAGE_NOT_LOW_COUNT = DEFAULT_MIN_STORAGE_NOT_LOW_COUNT;
/**
* Minimum # of connectivity jobs that must be ready in order to force the JMS to schedule
* things early. 1 == Run connectivity jobs as soon as ready.
*/
int MIN_CONNECTIVITY_COUNT = DEFAULT_MIN_CONNECTIVITY_COUNT;
/**
* Minimum # of content trigger jobs that must be ready in order to force the JMS to
* schedule things early.
*/
int MIN_CONTENT_COUNT = DEFAULT_MIN_CONTENT_COUNT;
/**
* Minimum # of jobs (with no particular constraints) for which the JMS will be happy
* running some work early. This (and thus the other min counts) is now set to 1, to
* prevent any batching at this level. Since we now do batching through doze, that is
* a much better mechanism.
*/
int MIN_READY_JOBS_COUNT = DEFAULT_MIN_READY_JOBS_COUNT;
/**
* Minimum # of non-ACTIVE jobs for which the JMS will be happy running some work early.
*/
@@ -687,20 +646,6 @@ public class JobSchedulerService extends com.android.server.SystemService
Slog.e(TAG, "Bad jobscheduler settings", e);
}
MIN_IDLE_COUNT = mParser.getInt(KEY_MIN_IDLE_COUNT,
DEFAULT_MIN_IDLE_COUNT);
MIN_CHARGING_COUNT = mParser.getInt(KEY_MIN_CHARGING_COUNT,
DEFAULT_MIN_CHARGING_COUNT);
MIN_BATTERY_NOT_LOW_COUNT = mParser.getInt(KEY_MIN_BATTERY_NOT_LOW_COUNT,
DEFAULT_MIN_BATTERY_NOT_LOW_COUNT);
MIN_STORAGE_NOT_LOW_COUNT = mParser.getInt(KEY_MIN_STORAGE_NOT_LOW_COUNT,
DEFAULT_MIN_STORAGE_NOT_LOW_COUNT);
MIN_CONNECTIVITY_COUNT = mParser.getInt(KEY_MIN_CONNECTIVITY_COUNT,
DEFAULT_MIN_CONNECTIVITY_COUNT);
MIN_CONTENT_COUNT = mParser.getInt(KEY_MIN_CONTENT_COUNT,
DEFAULT_MIN_CONTENT_COUNT);
MIN_READY_JOBS_COUNT = mParser.getInt(KEY_MIN_READY_JOBS_COUNT,
DEFAULT_MIN_READY_JOBS_COUNT);
MIN_READY_NON_ACTIVE_JOBS_COUNT = mParser.getInt(
KEY_MIN_READY_NON_ACTIVE_JOBS_COUNT,
DEFAULT_MIN_READY_NON_ACTIVE_JOBS_COUNT);
@@ -749,13 +694,6 @@ public class JobSchedulerService extends com.android.server.SystemService
void dump(IndentingPrintWriter pw) {
pw.println("Settings:");
pw.increaseIndent();
pw.printPair(KEY_MIN_IDLE_COUNT, MIN_IDLE_COUNT).println();
pw.printPair(KEY_MIN_CHARGING_COUNT, MIN_CHARGING_COUNT).println();
pw.printPair(KEY_MIN_BATTERY_NOT_LOW_COUNT, MIN_BATTERY_NOT_LOW_COUNT).println();
pw.printPair(KEY_MIN_STORAGE_NOT_LOW_COUNT, MIN_STORAGE_NOT_LOW_COUNT).println();
pw.printPair(KEY_MIN_CONNECTIVITY_COUNT, MIN_CONNECTIVITY_COUNT).println();
pw.printPair(KEY_MIN_CONTENT_COUNT, MIN_CONTENT_COUNT).println();
pw.printPair(KEY_MIN_READY_JOBS_COUNT, MIN_READY_JOBS_COUNT).println();
pw.printPair(KEY_MIN_READY_NON_ACTIVE_JOBS_COUNT,
MIN_READY_NON_ACTIVE_JOBS_COUNT).println();
pw.printPair(KEY_MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS,
@@ -790,13 +728,6 @@ public class JobSchedulerService extends com.android.server.SystemService
}
void dump(ProtoOutputStream proto) {
proto.write(ConstantsProto.MIN_IDLE_COUNT, MIN_IDLE_COUNT);
proto.write(ConstantsProto.MIN_CHARGING_COUNT, MIN_CHARGING_COUNT);
proto.write(ConstantsProto.MIN_BATTERY_NOT_LOW_COUNT, MIN_BATTERY_NOT_LOW_COUNT);
proto.write(ConstantsProto.MIN_STORAGE_NOT_LOW_COUNT, MIN_STORAGE_NOT_LOW_COUNT);
proto.write(ConstantsProto.MIN_CONNECTIVITY_COUNT, MIN_CONNECTIVITY_COUNT);
proto.write(ConstantsProto.MIN_CONTENT_COUNT, MIN_CONTENT_COUNT);
proto.write(ConstantsProto.MIN_READY_JOBS_COUNT, MIN_READY_JOBS_COUNT);
proto.write(ConstantsProto.MIN_READY_NON_ACTIVE_JOBS_COUNT,
MIN_READY_NON_ACTIVE_JOBS_COUNT);
proto.write(ConstantsProto.MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS,
@@ -2106,13 +2037,6 @@ public class JobSchedulerService extends com.android.server.SystemService
* policies on when we want to execute jobs.
*/
final class MaybeReadyJobQueueFunctor implements Consumer<JobStatus> {
int chargingCount;
int batteryNotLowCount;
int storageNotLowCount;
int idleCount;
int backoffCount;
int connectivityCount;
int contentCount;
int forceBatchedCount;
int unbatchedCount;
final List<JobStatus> runnableJobs = new ArrayList<>();
@@ -2135,13 +2059,25 @@ public class JobSchedulerService extends com.android.server.SystemService
}
} catch (RemoteException e) {
}
final boolean shouldForceBatchJob;
// Restricted jobs must always be batched
if (job.getEffectiveStandbyBucket() == RESTRICTED_INDEX
|| (mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT > 1
&& job.getEffectiveStandbyBucket() != ACTIVE_INDEX
&& (job.getFirstForceBatchedTimeElapsed() == 0
|| sElapsedRealtimeClock.millis() - job.getFirstForceBatchedTimeElapsed()
< mConstants.MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS))) {
if (job.getEffectiveStandbyBucket() == RESTRICTED_INDEX) {
shouldForceBatchJob = true;
} else if (job.getNumFailures() > 0) {
shouldForceBatchJob = false;
} else {
final long nowElapsed = sElapsedRealtimeClock.millis();
final boolean batchDelayExpired = job.getFirstForceBatchedTimeElapsed() > 0
&& nowElapsed - job.getFirstForceBatchedTimeElapsed()
>= mConstants.MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS;
shouldForceBatchJob =
mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT > 1
&& job.getEffectiveStandbyBucket() != ACTIVE_INDEX
&& !batchDelayExpired;
}
if (shouldForceBatchJob) {
// Force batching non-ACTIVE jobs. Don't include them in the other counts.
forceBatchedCount++;
if (job.getFirstForceBatchedTimeElapsed() == 0) {
@@ -2149,27 +2085,6 @@ public class JobSchedulerService extends com.android.server.SystemService
}
} else {
unbatchedCount++;
if (job.getNumFailures() > 0) {
backoffCount++;
}
if (job.hasIdleConstraint()) {
idleCount++;
}
if (job.hasConnectivityConstraint()) {
connectivityCount++;
}
if (job.hasChargingConstraint()) {
chargingCount++;
}
if (job.hasBatteryNotLowConstraint()) {
batteryNotLowCount++;
}
if (job.hasStorageNotLowConstraint()) {
storageNotLowCount++;
}
if (job.hasContentTriggerConstraint()) {
contentCount++;
}
}
runnableJobs.add(job);
} else {
@@ -2178,16 +2093,8 @@ public class JobSchedulerService extends com.android.server.SystemService
}
public void postProcess() {
if (backoffCount > 0 ||
idleCount >= mConstants.MIN_IDLE_COUNT ||
connectivityCount >= mConstants.MIN_CONNECTIVITY_COUNT ||
chargingCount >= mConstants.MIN_CHARGING_COUNT ||
batteryNotLowCount >= mConstants.MIN_BATTERY_NOT_LOW_COUNT ||
storageNotLowCount >= mConstants.MIN_STORAGE_NOT_LOW_COUNT ||
contentCount >= mConstants.MIN_CONTENT_COUNT ||
forceBatchedCount >= mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT ||
(unbatchedCount > 0 && (unbatchedCount + forceBatchedCount)
>= mConstants.MIN_READY_JOBS_COUNT)) {
if (unbatchedCount > 0
|| forceBatchedCount >= mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT) {
if (DEBUG) {
Slog.d(TAG, "maybeQueueReadyJobsForExecutionLocked: Running jobs.");
}
@@ -2208,13 +2115,6 @@ public class JobSchedulerService extends com.android.server.SystemService
@VisibleForTesting
void reset() {
chargingCount = 0;
idleCount = 0;
backoffCount = 0;
connectivityCount = 0;
batteryNotLowCount = 0;
storageNotLowCount = 0;
contentCount = 0;
forceBatchedCount = 0;
unbatchedCount = 0;
runnableJobs.clear();

31
core/proto/android/server/jobscheduler.proto
View File

@@ -170,30 +170,13 @@ message JobSchedulerServiceDumpProto {
message ConstantsProto {
option (.android.msg_privacy).dest = DEST_AUTOMATIC;
// Minimum # of idle jobs that must be ready in order to force the JMS to
// schedule things early.
optional int32 min_idle_count = 1;
// Minimum # of charging jobs that must be ready in order to force the JMS
// to schedule things early.
optional int32 min_charging_count = 2;
// Minimum # of "battery not low" jobs that must be ready in order to force
// the JMS to schedule things early.
optional int32 min_battery_not_low_count = 3;
// Minimum # of "storage not low" jobs that must be ready in order to force
// the JMS to schedule things early.
optional int32 min_storage_not_low_count = 4;
// Minimum # of connectivity jobs that must be ready in order to force the
// JMS to schedule things early. 1 == Run connectivity jobs as soon as
// ready.
optional int32 min_connectivity_count = 5;
// Minimum # of content trigger jobs that must be ready in order to force
// the JMS to schedule things early.
optional int32 min_content_count = 6;
// Minimum # of jobs (with no particular constraints) for which the JMS will
// be happy running some work early. This (and thus the other min counts)
// is now set to 1, to prevent any batching at this level. Since we now do
// batching through doze, that is a much better mechanism.
optional int32 min_ready_jobs_count = 7;
reserved 1; // min_idle_count
reserved 2; // min_charging_count
reserved 3; // min_battery_not_low_count
reserved 4; // min_storage_not_low_count
reserved 5; // min_connectivity_count
reserved 6; // min_content_count
reserved 7; // min_ready_jobs_count
// Minimum # of non-ACTIVE jobs for which the JMS will be happy running some work early.
optional int32 min_ready_non_active_jobs_count = 29;
// Don't batch a non-ACTIVE job if it's been delayed due to force batching attempts for

2
services/tests/mockingservicestests/src/com/android/server/job/JobSchedulerServiceTest.java
View File

@@ -683,8 +683,6 @@ public class JobSchedulerServiceTest {
mService.new MaybeReadyJobQueueFunctor();
mService.mConstants.MIN_READY_NON_ACTIVE_JOBS_COUNT = 5;
mService.mConstants.MAX_NON_ACTIVE_JOB_BATCH_DELAY_MS = HOUR_IN_MILLIS;
mService.mConstants.MIN_CONNECTIVITY_COUNT = 2;
mService.mConstants.MIN_READY_JOBS_COUNT = 1;
JobStatus job = createJobStatus(
"testRareJobBatching",