/*
|
* Copyright (C) 2018 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 com.android.server.job;
|
|
import android.app.ActivityManager;
|
import android.app.job.JobInfo;
|
import android.content.BroadcastReceiver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.os.Handler;
|
import android.os.PowerManager;
|
import android.os.RemoteException;
|
import android.util.Slog;
|
import android.util.TimeUtils;
|
import android.util.proto.ProtoOutputStream;
|
|
import com.android.internal.annotations.GuardedBy;
|
import com.android.internal.annotations.VisibleForTesting;
|
import com.android.internal.app.procstats.ProcessStats;
|
import com.android.internal.os.BackgroundThread;
|
import com.android.internal.util.IndentingPrintWriter;
|
import com.android.internal.util.StatLogger;
|
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;
|
|
import java.util.Iterator;
|
import java.util.List;
|
|
/**
|
* This class decides, given the various configuration and the system status, how many more jobs
|
* can start.
|
*/
|
class JobConcurrencyManager {
|
private static final String TAG = JobSchedulerService.TAG;
|
private static final boolean DEBUG = JobSchedulerService.DEBUG;
|
|
private final Object mLock;
|
private final JobSchedulerService mService;
|
private final JobSchedulerService.Constants mConstants;
|
private final Context mContext;
|
private final Handler mHandler;
|
|
private PowerManager mPowerManager;
|
|
private boolean mCurrentInteractiveState;
|
private boolean mEffectiveInteractiveState;
|
|
private long mLastScreenOnRealtime;
|
private long mLastScreenOffRealtime;
|
|
private static final int MAX_JOB_CONTEXTS_COUNT = JobSchedulerService.MAX_JOB_CONTEXTS_COUNT;
|
|
/**
|
* This array essentially stores the state of mActiveServices array.
|
* The ith index stores the job present on the ith JobServiceContext.
|
* We manipulate this array until we arrive at what jobs should be running on
|
* what JobServiceContext.
|
*/
|
JobStatus[] mRecycledAssignContextIdToJobMap = new JobStatus[MAX_JOB_CONTEXTS_COUNT];
|
|
boolean[] mRecycledSlotChanged = new boolean[MAX_JOB_CONTEXTS_COUNT];
|
|
int[] mRecycledPreferredUidForContext = new int[MAX_JOB_CONTEXTS_COUNT];
|
|
/** Max job counts according to the current system state. */
|
private JobSchedulerService.MaxJobCounts mMaxJobCounts;
|
|
private final JobCountTracker mJobCountTracker = new JobCountTracker();
|
|
/** Current memory trim level. */
|
private int mLastMemoryTrimLevel;
|
|
/** Used to throttle heavy API calls. */
|
private long mNextSystemStateRefreshTime;
|
private static final int SYSTEM_STATE_REFRESH_MIN_INTERVAL = 1000;
|
|
private final StatLogger mStatLogger = new StatLogger(new String[]{
|
"assignJobsToContexts",
|
"refreshSystemState",
|
});
|
|
interface Stats {
|
int ASSIGN_JOBS_TO_CONTEXTS = 0;
|
int REFRESH_SYSTEM_STATE = 1;
|
|
int COUNT = REFRESH_SYSTEM_STATE + 1;
|
}
|
|
JobConcurrencyManager(JobSchedulerService service) {
|
mService = service;
|
mLock = mService.mLock;
|
mConstants = service.mConstants;
|
mContext = service.getContext();
|
|
mHandler = BackgroundThread.getHandler();
|
}
|
|
public void onSystemReady() {
|
mPowerManager = mContext.getSystemService(PowerManager.class);
|
|
final IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_ON);
|
filter.addAction(Intent.ACTION_SCREEN_OFF);
|
mContext.registerReceiver(mReceiver, filter);
|
|
onInteractiveStateChanged(mPowerManager.isInteractive());
|
}
|
|
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
switch (intent.getAction()) {
|
case Intent.ACTION_SCREEN_ON:
|
onInteractiveStateChanged(true);
|
break;
|
case Intent.ACTION_SCREEN_OFF:
|
onInteractiveStateChanged(false);
|
break;
|
}
|
}
|
};
|
|
/**
|
* Called when the screen turns on / off.
|
*/
|
private void onInteractiveStateChanged(boolean interactive) {
|
synchronized (mLock) {
|
if (mCurrentInteractiveState == interactive) {
|
return;
|
}
|
mCurrentInteractiveState = interactive;
|
if (DEBUG) {
|
Slog.d(TAG, "Interactive: " + interactive);
|
}
|
|
final long nowRealtime = JobSchedulerService.sElapsedRealtimeClock.millis();
|
if (interactive) {
|
mLastScreenOnRealtime = nowRealtime;
|
mEffectiveInteractiveState = true;
|
|
mHandler.removeCallbacks(mRampUpForScreenOff);
|
} else {
|
mLastScreenOffRealtime = nowRealtime;
|
|
// Set mEffectiveInteractiveState to false after the delay, when we may increase
|
// the concurrency.
|
// We don't need a wakeup alarm here. When there's a pending job, there should
|
// also be jobs running too, meaning the device should be awake.
|
|
// 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.getValue());
|
}
|
}
|
}
|
|
private final Runnable mRampUpForScreenOff = this::rampUpForScreenOff;
|
|
/**
|
* Called in {@link Constants#SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS} after
|
* the screen turns off, in order to increase concurrency.
|
*/
|
private void rampUpForScreenOff() {
|
synchronized (mLock) {
|
// Make sure the screen has really been off for the configured duration.
|
// (There could be a race.)
|
if (!mEffectiveInteractiveState) {
|
return;
|
}
|
if (mLastScreenOnRealtime > mLastScreenOffRealtime) {
|
return;
|
}
|
final long now = JobSchedulerService.sElapsedRealtimeClock.millis();
|
if ((mLastScreenOffRealtime
|
+ mConstants.SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS.getValue())
|
> now) {
|
return;
|
}
|
|
mEffectiveInteractiveState = false;
|
|
if (DEBUG) {
|
Slog.d(TAG, "Ramping up concurrency");
|
}
|
|
mService.maybeRunPendingJobsLocked();
|
}
|
}
|
|
private boolean isFgJob(JobStatus job) {
|
return job.lastEvaluatedPriority >= JobInfo.PRIORITY_TOP_APP;
|
}
|
|
@GuardedBy("mLock")
|
private void refreshSystemStateLocked() {
|
final long nowUptime = JobSchedulerService.sUptimeMillisClock.millis();
|
|
// Only refresh the information every so often.
|
if (nowUptime < mNextSystemStateRefreshTime) {
|
return;
|
}
|
|
final long start = mStatLogger.getTime();
|
mNextSystemStateRefreshTime = nowUptime + SYSTEM_STATE_REFRESH_MIN_INTERVAL;
|
|
mLastMemoryTrimLevel = ProcessStats.ADJ_MEM_FACTOR_NORMAL;
|
try {
|
mLastMemoryTrimLevel = ActivityManager.getService().getMemoryTrimLevel();
|
} catch (RemoteException e) {
|
}
|
|
mStatLogger.logDurationStat(Stats.REFRESH_SYSTEM_STATE, start);
|
}
|
|
@GuardedBy("mLock")
|
private void updateMaxCountsLocked() {
|
refreshSystemStateLocked();
|
|
final MaxJobCountsPerMemoryTrimLevel jobCounts = mEffectiveInteractiveState
|
? mConstants.MAX_JOB_COUNTS_SCREEN_ON
|
: mConstants.MAX_JOB_COUNTS_SCREEN_OFF;
|
|
|
switch (mLastMemoryTrimLevel) {
|
case ProcessStats.ADJ_MEM_FACTOR_MODERATE:
|
mMaxJobCounts = jobCounts.moderate;
|
break;
|
case ProcessStats.ADJ_MEM_FACTOR_LOW:
|
mMaxJobCounts = jobCounts.low;
|
break;
|
case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:
|
mMaxJobCounts = jobCounts.critical;
|
break;
|
default:
|
mMaxJobCounts = jobCounts.normal;
|
break;
|
}
|
}
|
|
/**
|
* Takes jobs from pending queue and runs them on available contexts.
|
* If no contexts are available, preempts lower priority jobs to
|
* run higher priority ones.
|
* Lock on mJobs before calling this function.
|
*/
|
@GuardedBy("mLock")
|
void assignJobsToContextsLocked() {
|
final long start = mStatLogger.getTime();
|
|
assignJobsToContextsInternalLocked();
|
|
mStatLogger.logDurationStat(Stats.ASSIGN_JOBS_TO_CONTEXTS, start);
|
}
|
|
@GuardedBy("mLock")
|
private void assignJobsToContextsInternalLocked() {
|
if (DEBUG) {
|
Slog.d(TAG, printPendingQueueLocked());
|
}
|
|
final JobPackageTracker tracker = mService.mJobPackageTracker;
|
final List<JobStatus> pendingJobs = mService.mPendingJobs;
|
final List<JobServiceContext> activeServices = mService.mActiveServices;
|
final List<StateController> controllers = mService.mControllers;
|
|
updateMaxCountsLocked();
|
|
// To avoid GC churn, we recycle the arrays.
|
JobStatus[] contextIdToJobMap = mRecycledAssignContextIdToJobMap;
|
boolean[] slotChanged = mRecycledSlotChanged;
|
int[] preferredUidForContext = mRecycledPreferredUidForContext;
|
|
|
// Initialize the work variables and also count running jobs.
|
mJobCountTracker.reset(
|
mMaxJobCounts.getMaxTotal(),
|
mMaxJobCounts.getMaxBg(),
|
mMaxJobCounts.getMinBg());
|
|
for (int i=0; i<MAX_JOB_CONTEXTS_COUNT; i++) {
|
final JobServiceContext js = mService.mActiveServices.get(i);
|
final JobStatus status = js.getRunningJobLocked();
|
|
if ((contextIdToJobMap[i] = status) != null) {
|
mJobCountTracker.incrementRunningJobCount(isFgJob(status));
|
}
|
|
slotChanged[i] = false;
|
preferredUidForContext[i] = js.getPreferredUid();
|
}
|
if (DEBUG) {
|
Slog.d(TAG, printContextIdToJobMap(contextIdToJobMap, "running jobs initial"));
|
}
|
|
// Next, update the job priorities, and also count the pending FG / BG jobs.
|
for (int i = 0; i < pendingJobs.size(); i++) {
|
final JobStatus pending = pendingJobs.get(i);
|
|
// If job is already running, go to next job.
|
int jobRunningContext = findJobContextIdFromMap(pending, contextIdToJobMap);
|
if (jobRunningContext != -1) {
|
continue;
|
}
|
|
final int priority = mService.evaluateJobPriorityLocked(pending);
|
pending.lastEvaluatedPriority = priority;
|
|
mJobCountTracker.incrementPendingJobCount(isFgJob(pending));
|
}
|
|
mJobCountTracker.onCountDone();
|
|
for (int i = 0; i < pendingJobs.size(); i++) {
|
final JobStatus nextPending = pendingJobs.get(i);
|
|
// Unfortunately we need to repeat this relatively expensive check.
|
int jobRunningContext = findJobContextIdFromMap(nextPending, contextIdToJobMap);
|
if (jobRunningContext != -1) {
|
continue;
|
}
|
|
final boolean isPendingFg = isFgJob(nextPending);
|
|
// Find an available slot for nextPending. The context should be available OR
|
// it should have lowest priority among all running jobs
|
// (sharing the same Uid as nextPending)
|
int minPriorityForPreemption = Integer.MAX_VALUE;
|
int selectedContextId = -1;
|
boolean startingJob = false;
|
for (int j=0; j<MAX_JOB_CONTEXTS_COUNT; j++) {
|
JobStatus job = contextIdToJobMap[j];
|
int preferredUid = preferredUidForContext[j];
|
if (job == null) {
|
final boolean preferredUidOkay = (preferredUid == nextPending.getUid())
|
|| (preferredUid == JobServiceContext.NO_PREFERRED_UID);
|
|
if (preferredUidOkay && mJobCountTracker.canJobStart(isPendingFg)) {
|
// This slot is free, and we haven't yet hit the limit on
|
// concurrent jobs... we can just throw the job in to here.
|
selectedContextId = j;
|
startingJob = true;
|
break;
|
}
|
// No job on this context, but nextPending can't run here because
|
// the context has a preferred Uid or we have reached the limit on
|
// concurrent jobs.
|
continue;
|
}
|
if (job.getUid() != nextPending.getUid()) {
|
continue;
|
}
|
|
final int jobPriority = mService.evaluateJobPriorityLocked(job);
|
if (jobPriority >= nextPending.lastEvaluatedPriority) {
|
continue;
|
}
|
|
// TODO lastEvaluatedPriority should be evaluateJobPriorityLocked. (double check it)
|
if (minPriorityForPreemption > nextPending.lastEvaluatedPriority) {
|
minPriorityForPreemption = nextPending.lastEvaluatedPriority;
|
selectedContextId = j;
|
// In this case, we're just going to preempt a low priority job, we're not
|
// actually starting a job, so don't set startingJob.
|
}
|
}
|
if (selectedContextId != -1) {
|
contextIdToJobMap[selectedContextId] = nextPending;
|
slotChanged[selectedContextId] = true;
|
}
|
if (startingJob) {
|
// Increase the counters when we're going to start a job.
|
mJobCountTracker.onStartingNewJob(isPendingFg);
|
}
|
}
|
if (DEBUG) {
|
Slog.d(TAG, printContextIdToJobMap(contextIdToJobMap, "running jobs final"));
|
}
|
|
mJobCountTracker.logStatus();
|
|
tracker.noteConcurrency(mJobCountTracker.getTotalRunningJobCountToNote(),
|
mJobCountTracker.getFgRunningJobCountToNote());
|
|
for (int i=0; i<MAX_JOB_CONTEXTS_COUNT; i++) {
|
boolean preservePreferredUid = false;
|
if (slotChanged[i]) {
|
JobStatus js = activeServices.get(i).getRunningJobLocked();
|
if (js != null) {
|
if (DEBUG) {
|
Slog.d(TAG, "preempting job: "
|
+ activeServices.get(i).getRunningJobLocked());
|
}
|
// preferredUid will be set to uid of currently running job.
|
activeServices.get(i).preemptExecutingJobLocked();
|
preservePreferredUid = true;
|
} else {
|
final JobStatus pendingJob = contextIdToJobMap[i];
|
if (DEBUG) {
|
Slog.d(TAG, "About to run job on context "
|
+ i + ", job: " + pendingJob);
|
}
|
for (int ic=0; ic<controllers.size(); ic++) {
|
controllers.get(ic).prepareForExecutionLocked(pendingJob);
|
}
|
if (!activeServices.get(i).executeRunnableJob(pendingJob)) {
|
Slog.d(TAG, "Error executing " + pendingJob);
|
}
|
if (pendingJobs.remove(pendingJob)) {
|
tracker.noteNonpending(pendingJob);
|
}
|
}
|
}
|
if (!preservePreferredUid) {
|
activeServices.get(i).clearPreferredUid();
|
}
|
}
|
}
|
|
private static int findJobContextIdFromMap(JobStatus jobStatus, JobStatus[] map) {
|
for (int i=0; i<map.length; i++) {
|
if (map[i] != null && map[i].matches(jobStatus.getUid(), jobStatus.getJobId())) {
|
return i;
|
}
|
}
|
return -1;
|
}
|
|
@GuardedBy("mLock")
|
private String printPendingQueueLocked() {
|
StringBuilder s = new StringBuilder("Pending queue: ");
|
Iterator<JobStatus> it = mService.mPendingJobs.iterator();
|
while (it.hasNext()) {
|
JobStatus js = it.next();
|
s.append("(")
|
.append(js.getJob().getId())
|
.append(", ")
|
.append(js.getUid())
|
.append(") ");
|
}
|
return s.toString();
|
}
|
|
private static String printContextIdToJobMap(JobStatus[] map, String initial) {
|
StringBuilder s = new StringBuilder(initial + ": ");
|
for (int i=0; i<map.length; i++) {
|
s.append("(")
|
.append(map[i] == null? -1: map[i].getJobId())
|
.append(map[i] == null? -1: map[i].getUid())
|
.append(")" );
|
}
|
return s.toString();
|
}
|
|
|
public void dumpLocked(IndentingPrintWriter pw, long now, long nowRealtime) {
|
pw.println("Concurrency:");
|
|
pw.increaseIndent();
|
try {
|
pw.print("Screen state: current ");
|
pw.print(mCurrentInteractiveState ? "ON" : "OFF");
|
pw.print(" effective ");
|
pw.print(mEffectiveInteractiveState ? "ON" : "OFF");
|
pw.println();
|
|
pw.print("Last screen ON : ");
|
TimeUtils.dumpTimeWithDelta(pw, now - nowRealtime + mLastScreenOnRealtime, now);
|
pw.println();
|
|
pw.print("Last screen OFF: ");
|
TimeUtils.dumpTimeWithDelta(pw, now - nowRealtime + mLastScreenOffRealtime, now);
|
pw.println();
|
|
pw.println();
|
|
pw.println("Current max jobs:");
|
pw.println(" ");
|
pw.println(mJobCountTracker);
|
|
pw.println();
|
|
pw.print("mLastMemoryTrimLevel: ");
|
pw.print(mLastMemoryTrimLevel);
|
pw.println();
|
|
mStatLogger.dump(pw);
|
} finally {
|
pw.decreaseIndent();
|
}
|
}
|
|
public void dumpProtoLocked(ProtoOutputStream proto, long tag, long now, long nowRealtime) {
|
final long token = proto.start(tag);
|
|
proto.write(JobConcurrencyManagerProto.CURRENT_INTERACTIVE,
|
mCurrentInteractiveState);
|
proto.write(JobConcurrencyManagerProto.EFFECTIVE_INTERACTIVE,
|
mEffectiveInteractiveState);
|
|
proto.write(JobConcurrencyManagerProto.TIME_SINCE_LAST_SCREEN_ON_MS,
|
nowRealtime - mLastScreenOnRealtime);
|
proto.write(JobConcurrencyManagerProto.TIME_SINCE_LAST_SCREEN_OFF_MS,
|
nowRealtime - mLastScreenOffRealtime);
|
|
mJobCountTracker.dumpProto(proto, JobConcurrencyManagerProto.JOB_COUNT_TRACKER);
|
|
proto.write(JobConcurrencyManagerProto.MEMORY_TRIM_LEVEL,
|
mLastMemoryTrimLevel);
|
|
proto.end(token);
|
}
|
|
/**
|
* This class decides, taking into account {@link #mMaxJobCounts} and how mny jos are running /
|
* pending, how many more job can start.
|
*
|
* Extracted for testing and logging.
|
*/
|
@VisibleForTesting
|
static class JobCountTracker {
|
private int mConfigNumMaxTotalJobs;
|
private int mConfigNumMaxBgJobs;
|
private int mConfigNumMinBgJobs;
|
|
private int mNumRunningFgJobs;
|
private int mNumRunningBgJobs;
|
|
private int mNumPendingFgJobs;
|
private int mNumPendingBgJobs;
|
|
private int mNumStartingFgJobs;
|
private int mNumStartingBgJobs;
|
|
private int mNumReservedForBg;
|
private int mNumActualMaxFgJobs;
|
private int mNumActualMaxBgJobs;
|
|
void reset(int numTotalMaxJobs, int numMaxBgJobs, int numMinBgJobs) {
|
mConfigNumMaxTotalJobs = numTotalMaxJobs;
|
mConfigNumMaxBgJobs = numMaxBgJobs;
|
mConfigNumMinBgJobs = numMinBgJobs;
|
|
mNumRunningFgJobs = 0;
|
mNumRunningBgJobs = 0;
|
|
mNumPendingFgJobs = 0;
|
mNumPendingBgJobs = 0;
|
|
mNumStartingFgJobs = 0;
|
mNumStartingBgJobs = 0;
|
|
mNumReservedForBg = 0;
|
mNumActualMaxFgJobs = 0;
|
mNumActualMaxBgJobs = 0;
|
}
|
|
void incrementRunningJobCount(boolean isFg) {
|
if (isFg) {
|
mNumRunningFgJobs++;
|
} else {
|
mNumRunningBgJobs++;
|
}
|
}
|
|
void incrementPendingJobCount(boolean isFg) {
|
if (isFg) {
|
mNumPendingFgJobs++;
|
} else {
|
mNumPendingBgJobs++;
|
}
|
}
|
|
void onStartingNewJob(boolean isFg) {
|
if (isFg) {
|
mNumStartingFgJobs++;
|
} else {
|
mNumStartingBgJobs++;
|
}
|
}
|
|
void onCountDone() {
|
// Note some variables are used only here but are made class members in order to have
|
// them on logcat / dumpsys.
|
|
// How many slots should we allocate to BG jobs at least?
|
// That's basically "getMinBg()", but if there are less jobs, decrease it.
|
// (e.g. even if min-bg is 2, if there's only 1 running+pending job, this has to be 1.)
|
final int reservedForBg = Math.min(
|
mConfigNumMinBgJobs,
|
mNumRunningBgJobs + mNumPendingBgJobs);
|
|
// However, if there are FG jobs already running, we have to adjust it.
|
mNumReservedForBg = Math.min(reservedForBg,
|
mConfigNumMaxTotalJobs - mNumRunningFgJobs);
|
|
// Max FG is [total - [number needed for BG jobs]]
|
// [number needed for BG jobs] is the bigger one of [running BG] or [reserved BG]
|
final int maxFg =
|
mConfigNumMaxTotalJobs - Math.max(mNumRunningBgJobs, mNumReservedForBg);
|
|
// The above maxFg is the theoretical max. If there are less FG jobs, the actual
|
// max FG will be lower accordingly.
|
mNumActualMaxFgJobs = Math.min(
|
maxFg,
|
mNumRunningFgJobs + mNumPendingFgJobs);
|
|
// Max BG is [total - actual max FG], but cap at [config max BG].
|
final int maxBg = Math.min(
|
mConfigNumMaxBgJobs,
|
mConfigNumMaxTotalJobs - mNumActualMaxFgJobs);
|
|
// If there are less BG jobs than maxBg, then reduce the actual max BG accordingly.
|
// This isn't needed for the logic to work, but this will give consistent output
|
// on logcat and dumpsys.
|
mNumActualMaxBgJobs = Math.min(
|
maxBg,
|
mNumRunningBgJobs + mNumPendingBgJobs);
|
}
|
|
boolean canJobStart(boolean isFg) {
|
if (isFg) {
|
return mNumRunningFgJobs + mNumStartingFgJobs < mNumActualMaxFgJobs;
|
} else {
|
return mNumRunningBgJobs + mNumStartingBgJobs < mNumActualMaxBgJobs;
|
}
|
}
|
|
public int getNumStartingFgJobs() {
|
return mNumStartingFgJobs;
|
}
|
|
public int getNumStartingBgJobs() {
|
return mNumStartingBgJobs;
|
}
|
|
int getTotalRunningJobCountToNote() {
|
return mNumRunningFgJobs + mNumRunningBgJobs
|
+ mNumStartingFgJobs + mNumStartingBgJobs;
|
}
|
|
int getFgRunningJobCountToNote() {
|
return mNumRunningFgJobs + mNumStartingFgJobs;
|
}
|
|
void logStatus() {
|
if (DEBUG) {
|
Slog.d(TAG, "assignJobsToContexts: " + this);
|
}
|
}
|
|
public String toString() {
|
final int totalFg = mNumRunningFgJobs + mNumStartingFgJobs;
|
final int totalBg = mNumRunningBgJobs + mNumStartingBgJobs;
|
return String.format(
|
"Config={tot=%d bg min/max=%d/%d}"
|
+ " Running[FG/BG (total)]: %d / %d (%d)"
|
+ " Pending: %d / %d (%d)"
|
+ " Actual max: %d%s / %d%s (%d%s)"
|
+ " Res BG: %d"
|
+ " Starting: %d / %d (%d)"
|
+ " Total: %d%s / %d%s (%d%s)",
|
mConfigNumMaxTotalJobs,
|
mConfigNumMinBgJobs,
|
mConfigNumMaxBgJobs,
|
|
mNumRunningFgJobs, mNumRunningBgJobs,
|
mNumRunningFgJobs + mNumRunningBgJobs,
|
|
mNumPendingFgJobs, mNumPendingBgJobs,
|
mNumPendingFgJobs + mNumPendingBgJobs,
|
|
mNumActualMaxFgJobs, (totalFg <= mConfigNumMaxTotalJobs) ? "" : "*",
|
mNumActualMaxBgJobs, (totalBg <= mConfigNumMaxBgJobs) ? "" : "*",
|
|
mNumActualMaxFgJobs + mNumActualMaxBgJobs,
|
(mNumActualMaxFgJobs + mNumActualMaxBgJobs <= mConfigNumMaxTotalJobs)
|
? "" : "*",
|
|
mNumReservedForBg,
|
|
mNumStartingFgJobs, mNumStartingBgJobs, mNumStartingFgJobs + mNumStartingBgJobs,
|
|
totalFg, (totalFg <= mNumActualMaxFgJobs) ? "" : "*",
|
totalBg, (totalBg <= mNumActualMaxBgJobs) ? "" : "*",
|
totalFg + totalBg, (totalFg + totalBg <= mConfigNumMaxTotalJobs) ? "" : "*"
|
);
|
}
|
|
public void dumpProto(ProtoOutputStream proto, long fieldId) {
|
final long token = proto.start(fieldId);
|
|
proto.write(JobCountTrackerProto.CONFIG_NUM_MAX_TOTAL_JOBS, mConfigNumMaxTotalJobs);
|
proto.write(JobCountTrackerProto.CONFIG_NUM_MAX_BG_JOBS, mConfigNumMaxBgJobs);
|
proto.write(JobCountTrackerProto.CONFIG_NUM_MIN_BG_JOBS, mConfigNumMinBgJobs);
|
|
proto.write(JobCountTrackerProto.NUM_RUNNING_FG_JOBS, mNumRunningFgJobs);
|
proto.write(JobCountTrackerProto.NUM_RUNNING_BG_JOBS, mNumRunningBgJobs);
|
|
proto.write(JobCountTrackerProto.NUM_PENDING_FG_JOBS, mNumPendingFgJobs);
|
proto.write(JobCountTrackerProto.NUM_PENDING_BG_JOBS, mNumPendingBgJobs);
|
|
proto.end(token);
|
}
|
}
|
}
|
