Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit f731c420 authored by Makoto Onuki's avatar Makoto Onuki
Browse files

Add proto dumpsys for JobConcurrencyManager 

Also address the left over comments from the previous change.

Test: atest MaxJobCountsTest
Test: manual test with "dumpsys jobscheduler"
Test: manual test with "incident_report jobscheduler"

Bug: 111360323

Change-Id: Ic99ba028aea168a18a78c986bba8a2e93459b40a
parent 065aac1a

core/proto/android/server/jobscheduler.proto

+81 −1
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ import "frameworks/base/core/proto/android/os/persistablebundle.proto"; 
import "frameworks/base/core/proto/android/server/forceappstandbytracker.proto";

import "frameworks/base/libs/incident/proto/android/privacy.proto";



// Next tag: 21

message JobSchedulerServiceDumpProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;
@@ -139,9 +140,13 @@ message JobSchedulerServiceDumpProto { 
    // The current limit on the number of concurrent JobServiceContext entries

    // we want to keep actively running a job.

    optional int32 max_active_jobs = 13;



    // Dump from JobConcurrencyManager.

    optional JobConcurrencyManagerProto concurrency_manager = 20;

}



// A com.android.server.job.JobSchedulerService.Constants object.

// Next tag: 29

message ConstantsProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;
@@ -254,7 +259,39 @@ message ConstantsProto { 
    }

    optional QuotaController quota_controller = 24;



    // Next tag: 26

    // Max number of jobs, when screen is ON.

    optional MaxJobCountsPerMemoryTrimLevelProto max_job_counts_screen_on = 26;



    // Max number of jobs, when screen is OFF.

    optional MaxJobCountsPerMemoryTrimLevelProto max_job_counts_screen_off = 27;



    // In this time after screen turns on, we increase job concurrency.

    optional int32 screen_off_job_concurrency_increase_delay_ms = 28;

}



// Next tag: 4

message MaxJobCountsProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;



    // Total number of jobs to run simultaneously.

    optional int32 total_jobs = 1;



    // Max number of BG (== owned by non-TOP apps) jobs to run simultaneously.

    optional int32 max_bg = 2;



    // We try to run at least this many BG (== owned by non-TOP apps) jobs, when there are any

    // pending, rather than always running the TOTAL number of FG jobs.

    optional int32 min_bg = 3;

}



// Next tag: 5

message MaxJobCountsPerMemoryTrimLevelProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;



    optional MaxJobCountsProto normal = 1;

    optional MaxJobCountsProto moderate = 2;

    optional MaxJobCountsProto low = 3;

    optional MaxJobCountsProto critical = 4;

}



message StateControllerProto {
@@ -788,3 +825,46 @@ message JobStatusDumpProto { 


    // Next tag: 28

}



// Dump from com.android.server.job.JobConcurrencyManager.

// Next tag: 7

message JobConcurrencyManagerProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;



    // Whether the device is interactive (== screen on) now or not.

    optional bool current_interactive = 1;

    // Similar to current_interactive, screen on or not, but it takes into account the off timeout.

    optional bool effective_interactive = 2;

    // How many milliseconds have passed since the last screen on. (i.e. 1000 == 1 sec ago)

    optional int64 time_since_last_screen_on_ms = 3;

    // How many milliseconds have passed since the last screen off. (i.e. 1000 == 1 sec ago)

    optional int64 time_since_last_screen_off_ms = 4;

    // Current max number of jobs.

    optional JobCountTrackerProto job_count_tracker = 5;

    // Current memory trim level.

    optional int32 memory_trim_level = 6;

}



// Dump from com.android.server.job.JobConcurrencyManager.JobCountTracker.

// Next tag: 8

message JobCountTrackerProto {

    option (.android.msg_privacy).dest = DEST_AUTOMATIC;



    // Number of total jos that can run simultaneously.

    optional int32 config_num_max_total_jobs = 1;

    // Number of background jos that can run simultaneously.

    optional int32 config_num_max_bg_jobs = 2;

    // Out of total jobs, this many background jobs should be guaranteed to be executed, even if

    // there are the config_num_max_total_jobs count of foreground jobs pending.

    optional int32 config_num_min_bg_jobs = 3;



    // Number of running foreground jobs.

    optional int32 num_running_fg_jobs = 4;

    // Number of running background jobs.

    optional int32 num_running_bg_jobs = 5;



    // Number of pending foreground jobs.

    optional int32 num_pending_fg_jobs = 6;

    // Number of pending background jobs.

    optional int32 num_pending_bg_jobs = 7;

}

services/core/java/com/android/server/job/JobConcurrencyManager.java

+73 −53
Original line number Diff line number Diff line
@@ -36,6 +36,7 @@ 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;
@@ -148,14 +149,14 @@ class JobConcurrencyManager { 
                Slog.d(TAG, "Interactive: " + interactive);

            }



            final long now = JobSchedulerService.sElapsedRealtimeClock.millis();

            final long nowRealtime = JobSchedulerService.sElapsedRealtimeClock.millis();

            if (interactive) {

                mLastScreenOnRealtime = now;

                mLastScreenOnRealtime = nowRealtime;

                mEffectiveInteractiveState = true;



                mHandler.removeCallbacks(mRampUpForScreenOff);

            } else {

                mLastScreenOffRealtime = now;

                mLastScreenOffRealtime = nowRealtime;



                // Set mEffectiveInteractiveState to false after the delay, when we may increase

                // the concurrency.
@@ -232,40 +233,26 @@ class JobConcurrencyManager { 
    private void updateMaxCountsLocked() {

        refreshSystemStateLocked();



        if (mEffectiveInteractiveState) {

            // Screen on

            switch (mLastMemoryTrimLevel) {

                case ProcessStats.ADJ_MEM_FACTOR_MODERATE:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_ON_MODERATE;

                    break;

                case ProcessStats.ADJ_MEM_FACTOR_LOW:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_ON_LOW;

                    break;

                case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_ON_CRITICAL;

                    break;

                default:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_ON_NORMAL;

                    break;

            }

        } else {

            // Screen off

        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 = mConstants.MAX_JOB_COUNTS_OFF_MODERATE;

                mMaxJobCounts = jobCounts.moderate;

                break;

            case ProcessStats.ADJ_MEM_FACTOR_LOW:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_OFF_LOW;

                mMaxJobCounts = jobCounts.low;

                break;

            case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_OFF_CRITICAL;

                mMaxJobCounts = jobCounts.critical;

                break;

            default:

                    mMaxJobCounts = mConstants.MAX_JOB_COUNTS_OFF_NORMAL;

                mMaxJobCounts = jobCounts.normal;

                break;

        }

    }

    }



    /**

     * Takes jobs from pending queue and runs them on available contexts.
@@ -303,7 +290,7 @@ class JobConcurrencyManager { 


        // Initialize the work variables and also count running jobs.

        mJobCountTracker.reset(

                mMaxJobCounts.getTotalMax(),

                mMaxJobCounts.getMaxTotal(),

                mMaxJobCounts.getMaxBg(),

                mMaxJobCounts.getMinBg());
@@ -482,10 +469,7 @@ class JobConcurrencyManager { 
    }





    public void dumpLocked(IndentingPrintWriter pw) {

        final long now = System.currentTimeMillis();

        final long nowRealtime = JobSchedulerService.sElapsedRealtimeClock.millis();



    public void dumpLocked(IndentingPrintWriter pw, long now, long nowRealtime) {

        pw.println("Concurrency:");



        pw.increaseIndent();
@@ -522,19 +506,36 @@ class JobConcurrencyManager { 
        }

    }



    public void dumpProtoLocked(ProtoOutputStream proto) {

        // TODO Implement it.

    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 many jos are running /

     * 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 mConfigNumTotalMaxJobs;

        private int mConfigNumMaxTotalJobs;

        private int mConfigNumMaxBgJobs;

        private int mConfigNumMinBgJobs;
@@ -552,7 +553,7 @@ class JobConcurrencyManager { 
        private int mNumActualMaxBgJobs;



        void reset(int numTotalMaxJobs, int numMaxBgJobs, int numMinBgJobs) {

            mConfigNumTotalMaxJobs = numTotalMaxJobs;

            mConfigNumMaxTotalJobs = numTotalMaxJobs;

            mConfigNumMaxBgJobs = numMaxBgJobs;

            mConfigNumMinBgJobs = numMinBgJobs;
@@ -607,12 +608,12 @@ class JobConcurrencyManager { 


            // However, if there are FG jobs already running, we have to adjust it.

            mNumReservedForBg = Math.min(reservedForBg,

                    mConfigNumTotalMaxJobs - mNumRunningFgJobs);

                    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 =

                    mConfigNumTotalMaxJobs - Math.max(mNumRunningBgJobs, mNumReservedForBg);

                    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.
@@ -623,7 +624,7 @@ class JobConcurrencyManager { 
            // Max BG is [total - actual max FG], but cap at [config max BG].

            final int maxBg = Math.min(

                    mConfigNumMaxBgJobs,

                    mConfigNumTotalMaxJobs - mNumActualMaxFgJobs);

                    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
@@ -669,12 +670,13 @@ class JobConcurrencyManager { 
            final int totalBg = mNumRunningBgJobs + mNumStartingBgJobs;

            return String.format(

                    "Config={tot=%d bg min/max=%d/%d}"

                            + " Running: %d / %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)",

                    mConfigNumTotalMaxJobs,

                    mConfigNumMaxTotalJobs,

                    mConfigNumMinBgJobs,

                    mConfigNumMaxBgJobs,
@@ -684,19 +686,37 @@ class JobConcurrencyManager { 
                    mNumPendingFgJobs, mNumPendingBgJobs,

                    mNumPendingFgJobs + mNumPendingBgJobs,



                    mNumActualMaxFgJobs, (totalFg <= mConfigNumTotalMaxJobs) ? "" : "*",

                    mNumActualMaxFgJobs, (totalFg <= mConfigNumMaxTotalJobs) ? "" : "*",

                    mNumActualMaxBgJobs, (totalBg <= mConfigNumMaxBgJobs) ? "" : "*",



                    mNumActualMaxFgJobs + mNumActualMaxBgJobs,

                    (mNumActualMaxFgJobs + mNumActualMaxBgJobs <= mConfigNumTotalMaxJobs)

                    (mNumActualMaxFgJobs + mNumActualMaxBgJobs <= mConfigNumMaxTotalJobs)

                            ? "" : "*",



                    mNumReservedForBg,



                    mNumStartingFgJobs, mNumStartingBgJobs, mNumStartingFgJobs + mNumStartingBgJobs,



                    totalFg, (totalFg <= mNumActualMaxFgJobs) ? "" : "*",

                    totalBg, (totalBg <= mNumActualMaxBgJobs) ? "" : "*",

                    totalFg + totalBg, (totalFg + totalBg <= mConfigNumTotalMaxJobs) ? "" : "*"

                    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);

        }

    }

}

services/core/java/com/android/server/job/JobSchedulerService.java

+107 −63
Original line number Diff line number Diff line
@@ -366,14 +366,20 @@ public class JobSchedulerService extends com.android.server.SystemService 
            }

        }



        public int getTotalMax() {

        /** Total number of jobs to run simultaneously. */

        public int getMaxTotal() {

            return mTotal.getValue();

        }



        /** Max number of BG (== owned by non-TOP apps) jobs to run simultaneously. */

        public int getMaxBg() {

            return mMaxBg.getValue();

        }



        /**

         * We try to run at least this many BG (== owned by non-TOP apps) jobs, when there are any

         * pending, rather than always running the TOTAL number of FG jobs.

         */

        public int getMinBg() {

            return mMinBg.getValue();

        }
@@ -384,10 +390,39 @@ public class JobSchedulerService extends com.android.server.SystemService 
            mMinBg.dump(pw, prefix);

        }



        public void dumpProto(ProtoOutputStream proto, long tagTotal, long tagBg) {

            mTotal.dumpProto(proto, tagTotal);

            mMaxBg.dumpProto(proto, tagBg);

            mMinBg.dumpProto(proto, tagBg);

        public void dumpProto(ProtoOutputStream proto, long fieldId) {

            final long token = proto.start(fieldId);

            mTotal.dumpProto(proto, MaxJobCountsProto.TOTAL_JOBS);

            mMaxBg.dumpProto(proto, MaxJobCountsProto.MAX_BG);

            mMinBg.dumpProto(proto, MaxJobCountsProto.MIN_BG);

            proto.end(token);

        }

    }



    /** {@link MaxJobCounts} for each memory trim level. */

    static class MaxJobCountsPerMemoryTrimLevel {

        public final MaxJobCounts normal;

        public final MaxJobCounts moderate;

        public final MaxJobCounts low;

        public final MaxJobCounts critical;



        MaxJobCountsPerMemoryTrimLevel(

                MaxJobCounts normal,

                MaxJobCounts moderate, MaxJobCounts low,

                MaxJobCounts critical) {

            this.normal = normal;

            this.moderate = moderate;

            this.low = low;

            this.critical = critical;

        }



        public void dumpProto(ProtoOutputStream proto, long fieldId) {

            final long token = proto.start(fieldId);

            normal.dumpProto(proto, MaxJobCountsPerMemoryTrimLevelProto.NORMAL);

            moderate.dumpProto(proto, MaxJobCountsPerMemoryTrimLevelProto.MODERATE);

            low.dumpProto(proto, MaxJobCountsPerMemoryTrimLevelProto.LOW);

            critical.dumpProto(proto, MaxJobCountsPerMemoryTrimLevelProto.CRITICAL);

            proto.end(token);

        }

    }
@@ -527,45 +562,44 @@ public class JobSchedulerService extends com.android.server.SystemService 
        float MODERATE_USE_FACTOR = DEFAULT_MODERATE_USE_FACTOR;



        // Max job counts for screen on / off, for each memory trim level.

        final MaxJobCounts MAX_JOB_COUNTS_ON_NORMAL = new MaxJobCounts(

        final MaxJobCountsPerMemoryTrimLevel MAX_JOB_COUNTS_SCREEN_ON =

                new MaxJobCountsPerMemoryTrimLevel(

                        new MaxJobCounts(

                                8, "max_job_total_on_normal",

                                6, "max_job_max_bg_on_normal",

                2, "max_job_min_bg_on_normal");



        final MaxJobCounts MAX_JOB_COUNTS_ON_MODERATE = new MaxJobCounts(

                                2, "max_job_min_bg_on_normal"),

                        new MaxJobCounts(

                                8, "max_job_total_on_moderate",

                                4, "max_job_max_bg_on_moderate",

                2, "max_job_min_bg_on_moderate");



        final MaxJobCounts MAX_JOB_COUNTS_ON_LOW = new MaxJobCounts(

                                2, "max_job_min_bg_on_moderate"),

                        new MaxJobCounts(

                                5, "max_job_total_on_low",

                                1, "max_job_max_bg_on_low",

                1, "max_job_min_bg_on_low");



        final MaxJobCounts MAX_JOB_COUNTS_ON_CRITICAL = new MaxJobCounts(

                                1, "max_job_min_bg_on_low"),

                        new MaxJobCounts(

                                5, "max_job_total_on_critical",

                                1, "max_job_max_bg_on_critical",

                1, "max_job_min_bg_on_critical");

                                1, "max_job_min_bg_on_critical"));



        final MaxJobCounts MAX_JOB_COUNTS_OFF_NORMAL = new MaxJobCounts(

        final MaxJobCountsPerMemoryTrimLevel MAX_JOB_COUNTS_SCREEN_OFF =

                new MaxJobCountsPerMemoryTrimLevel(

                        new MaxJobCounts(

                                10, "max_job_total_off_normal",

                                6, "max_job_max_bg_off_normal",

                2, "max_job_min_bg_off_normal");



        final MaxJobCounts MAX_JOB_COUNTS_OFF_MODERATE = new MaxJobCounts(

                                2, "max_job_min_bg_off_normal"),

                        new MaxJobCounts(

                                10, "max_job_total_off_moderate",

                                4, "max_job_max_bg_off_moderate",

                2, "max_job_min_bg_off_moderate");



        final MaxJobCounts MAX_JOB_COUNTS_OFF_LOW = new MaxJobCounts(

                                2, "max_job_min_bg_off_moderate"),

                        new MaxJobCounts(

                                5, "max_job_total_off_low",

                                1, "max_job_max_bg_off_low",

                1, "max_job_min_bg_off_low");



        final MaxJobCounts MAX_JOB_COUNTS_OFF_CRITICAL = new MaxJobCounts(

                                1, "max_job_min_bg_off_low"),

                        new MaxJobCounts(

                                5, "max_job_total_off_critical",

                                1, "max_job_max_bg_off_critical",

                1, "max_job_min_bg_off_critical");

                                1, "max_job_min_bg_off_critical"));





        /** Wait for this long after screen off before increasing the job concurrency. */

        final KeyValueListParser.IntValue SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS =
@@ -712,15 +746,15 @@ public class JobSchedulerService extends com.android.server.SystemService 
            MODERATE_USE_FACTOR = mParser.getFloat(KEY_MODERATE_USE_FACTOR,

                    DEFAULT_MODERATE_USE_FACTOR);



            MAX_JOB_COUNTS_ON_NORMAL.parse(mParser);

            MAX_JOB_COUNTS_ON_MODERATE.parse(mParser);

            MAX_JOB_COUNTS_ON_LOW.parse(mParser);

            MAX_JOB_COUNTS_ON_CRITICAL.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_ON.normal.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_ON.moderate.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_ON.low.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_ON.critical.parse(mParser);



            MAX_JOB_COUNTS_OFF_NORMAL.parse(mParser);

            MAX_JOB_COUNTS_OFF_MODERATE.parse(mParser);

            MAX_JOB_COUNTS_OFF_LOW.parse(mParser);

            MAX_JOB_COUNTS_OFF_CRITICAL.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_OFF.normal.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_OFF.moderate.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_OFF.low.parse(mParser);

            MAX_JOB_COUNTS_SCREEN_OFF.critical.parse(mParser);



            MAX_STANDARD_RESCHEDULE_COUNT = mParser.getInt(KEY_MAX_STANDARD_RESCHEDULE_COUNT,

                    DEFAULT_MAX_STANDARD_RESCHEDULE_COUNT);
@@ -782,15 +816,17 @@ public class JobSchedulerService extends com.android.server.SystemService 
            pw.printPair(KEY_HEAVY_USE_FACTOR, HEAVY_USE_FACTOR).println();

            pw.printPair(KEY_MODERATE_USE_FACTOR, MODERATE_USE_FACTOR).println();



            MAX_JOB_COUNTS_ON_NORMAL.dump(pw, "");

            MAX_JOB_COUNTS_ON_MODERATE.dump(pw, "");

            MAX_JOB_COUNTS_ON_LOW.dump(pw, "");

            MAX_JOB_COUNTS_ON_CRITICAL.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_ON.normal.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_ON.moderate.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_ON.low.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_ON.critical.dump(pw, "");



            MAX_JOB_COUNTS_SCREEN_OFF.normal.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_OFF.moderate.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_OFF.low.dump(pw, "");

            MAX_JOB_COUNTS_SCREEN_OFF.critical.dump(pw, "");



            MAX_JOB_COUNTS_OFF_NORMAL.dump(pw, "");

            MAX_JOB_COUNTS_OFF_MODERATE.dump(pw, "");

            MAX_JOB_COUNTS_OFF_LOW.dump(pw, "");

            MAX_JOB_COUNTS_OFF_CRITICAL.dump(pw, "");

            SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS.dump(pw, "");



            pw.printPair(KEY_MAX_STANDARD_RESCHEDULE_COUNT, MAX_STANDARD_RESCHEDULE_COUNT).println();

            pw.printPair(KEY_MAX_WORK_RESCHEDULE_COUNT, MAX_WORK_RESCHEDULE_COUNT).println();
@@ -838,7 +874,11 @@ public class JobSchedulerService extends com.android.server.SystemService 
            proto.write(ConstantsProto.HEAVY_USE_FACTOR, HEAVY_USE_FACTOR);

            proto.write(ConstantsProto.MODERATE_USE_FACTOR, MODERATE_USE_FACTOR);



            // TODO Dump max job counts.

            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);



            SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS.dumpProto(proto,

                    ConstantsProto.SCREEN_OFF_JOB_CONCURRENCY_INCREASE_DELAY_MS);



            proto.write(ConstantsProto.MAX_STANDARD_RESCHEDULE_COUNT, MAX_STANDARD_RESCHEDULE_COUNT);

            proto.write(ConstantsProto.MAX_WORK_RESCHEDULE_COUNT, MAX_WORK_RESCHEDULE_COUNT);
@@ -3282,8 +3322,10 @@ public class JobSchedulerService extends com.android.server.SystemService 


    void dumpInternal(final IndentingPrintWriter pw, int filterUid) {

        final int filterUidFinal = UserHandle.getAppId(filterUid);

        final long now = sSystemClock.millis();

        final long nowElapsed = sElapsedRealtimeClock.millis();

        final long nowUptime = sUptimeMillisClock.millis();



        final Predicate<JobStatus> predicate = (js) -> {

            return filterUidFinal == -1 || UserHandle.getAppId(js.getUid()) == filterUidFinal

                    || UserHandle.getAppId(js.getSourceUid()) == filterUidFinal;
@@ -3459,7 +3501,7 @@ public class JobSchedulerService extends com.android.server.SystemService 
            }

            pw.println();



            mConcurrencyManager.dumpLocked(pw);

            mConcurrencyManager.dumpLocked(pw, now, nowElapsed);



            pw.println();

            pw.print("PersistStats: ");
@@ -3471,6 +3513,7 @@ public class JobSchedulerService extends com.android.server.SystemService 
    void dumpInternalProto(final FileDescriptor fd, int filterUid) {

        ProtoOutputStream proto = new ProtoOutputStream(fd);

        final int filterUidFinal = UserHandle.getAppId(filterUid);

        final long now = sSystemClock.millis();

        final long nowElapsed = sElapsedRealtimeClock.millis();

        final long nowUptime = sUptimeMillisClock.millis();

        final Predicate<JobStatus> predicate = (js) -> {
@@ -3614,7 +3657,8 @@ public class JobSchedulerService extends com.android.server.SystemService 
                proto.write(JobSchedulerServiceDumpProto.IS_READY_TO_ROCK, mReadyToRock);

                proto.write(JobSchedulerServiceDumpProto.REPORTED_ACTIVE, mReportedActive);

            }

            mConcurrencyManager.dumpProtoLocked(proto);

            mConcurrencyManager.dumpProtoLocked(proto,

                    JobSchedulerServiceDumpProto.CONCURRENCY_MANAGER, now, nowElapsed);

        }



        proto.flush();

services/tests/servicestests/src/com/android/server/job/MaxJobCountsTest.java

+9 −4

File changed.

Preview size limit exceeded, changes collapsed.