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

Commit 414923e8 authored by Edgar Arriaga's avatar Edgar Arriaga Committed by Edgar Arriaga García
Browse files

Add some compaction statistics around throttling 

Adding some statistics that can be helpful on bugreports for finding
when compaction is being over triggered.

Bug: 232296251
Test: dumpsys activity
Change-Id: I686aa2501cc8781c5939260a00bfda380890bf08
parent 6b22279c

services/core/java/com/android/server/am/CachedAppOptimizer.java

+49 −1
Original line number Diff line number Diff line
@@ -341,10 +341,24 @@ public final class CachedAppOptimizer { 
                }

    };



    // Compaction Stats

    private int mSomeCompactionCount;

    private int mFullCompactionCount;

    private int mPersistentCompactionCount;

    private int mBfgsCompactionCount;

    private long mSomeCompactRequest;

    private long mFullCompactRequest;

    private long mPersistentCompactRequest;

    private long mBfgsCompactRequest;

    private long mProcCompactionsRequested;

    private long mProcCompactionsPerformed;

    private long mProcCompactionsNoPidThrottled;

    private long mProcCompactionsOomAdjThrottled;

    private long mProcCompactionsTimeThrottled;

    private long mProcCompactionsRSSThrottled;

    private long mProcCompactionsMiscThrottled;

    private long mSystemCompactionsPerformed;



    private final ProcessDependencies mProcessDependencies;

    private final ProcLocksReader mProcLocksReader;
@@ -436,9 +450,31 @@ public final class CachedAppOptimizer { 
            pw.println("  "  + KEY_COMPACT_PROC_STATE_THROTTLE + "="

                    + Arrays.toString(mProcStateThrottle.toArray(new Integer[0])));



            pw.println("  " + mSomeCompactionCount + " some, " + mFullCompactionCount

            pw.println(" Requested:  " + mSomeCompactRequest + " some, " + mFullCompactRequest

                    + " full, " + mPersistentCompactRequest + " persistent, "

                    + mBfgsCompactRequest + " BFGS compactions.");

            pw.println(" Performed: " + mSomeCompactionCount + " some, " + mFullCompactionCount

                    + " full, " + mPersistentCompactionCount + " persistent, "

                    + mBfgsCompactionCount + " BFGS compactions.");

            pw.println(" Process Compactions Requested: " + mProcCompactionsRequested);

            pw.println(" Process Compactions Performed: " + mProcCompactionsPerformed);

            long compactionsThrottled = mProcCompactionsRequested - mProcCompactionsPerformed;

            pw.println(" Process Compactions Throttled: " + compactionsThrottled);

            double compactThrottlePercentage =

                    (compactionsThrottled / (double) mProcCompactionsRequested) * 100.0;

            pw.println(" Process Compactions Throttle Percentage: " + compactThrottlePercentage);

            pw.println("        NoPid Throttled: " + mProcCompactionsNoPidThrottled);

            pw.println("        OomAdj Throttled: " + mProcCompactionsOomAdjThrottled);

            pw.println("        Time Throttled: " + mProcCompactionsTimeThrottled);

            pw.println("        RSS Throttled: " + mProcCompactionsRSSThrottled);

            pw.println("        Misc Throttled: " + mProcCompactionsMiscThrottled);

            long unaccountedThrottled = compactionsThrottled - mProcCompactionsNoPidThrottled

                    - mProcCompactionsOomAdjThrottled - mProcCompactionsTimeThrottled

                    - mProcCompactionsRSSThrottled - mProcCompactionsMiscThrottled;

            // Any throttle that was not part of the previous categories

            pw.println("        Unaccounted Throttled: " + unaccountedThrottled);



            pw.println(" System Compactions Performed: " + mSystemCompactionsPerformed);



            pw.println("  Tracking last compaction stats for " + mLastCompactionStats.size()

                    + " processes.");
@@ -479,6 +515,7 @@ public final class CachedAppOptimizer { 
    @GuardedBy("mProcLock")

    void compactAppSome(ProcessRecord app, boolean force) {

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_SOME);

        ++mSomeCompactRequest;

        compactApp(app, force, "some");

    }
@@ -519,6 +556,7 @@ public final class CachedAppOptimizer { 
                    " compactAppFull requested for " + app.processName + " force: " + force

                            + " oomAdjEnteredCached: " + oomAdjEnteredCached);

        }

        ++mFullCompactRequest;

        // Apply OOM adj score throttle for Full App Compaction.

        if (force || oomAdjEnteredCached) {

            app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_FULL);
@@ -535,6 +573,7 @@ public final class CachedAppOptimizer { 
    @GuardedBy("mProcLock")

    void compactAppPersistent(ProcessRecord app) {

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_PERSISTENT);

        ++mPersistentCompactRequest;

        compactApp(app, false, "Persistent");

    }
@@ -573,6 +612,7 @@ public final class CachedAppOptimizer { 


    @GuardedBy("mProcLock")

    void compactAppBfgs(ProcessRecord app) {

        ++mBfgsCompactRequest;

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_BFGS);

        compactApp(app, false, " Bfgs");

    }
@@ -1447,27 +1487,33 @@ public final class CachedAppOptimizer { 
                        lastCompactTime = opt.getLastCompactTime();

                    }



                    ++mProcCompactionsRequested;

                    long[] rssBefore;

                    if (pid == 0) {

                        // not a real process, either one being launched or one being killed

                        if (DEBUG_COMPACTION) {

                            Slog.d(TAG_AM, "Compaction failed, pid is 0");

                        }

                        ++mProcCompactionsNoPidThrottled;

                        return;

                    }



                    if (!forceCompaction) {

                        if (shouldOomAdjThrottleCompaction(proc, requestedAction)) {

                            ++mProcCompactionsOomAdjThrottled;

                            return;

                        }

                        if (shouldTimeThrottleCompaction(proc, start, requestedAction)) {

                            ++mProcCompactionsTimeThrottled;

                            return;

                        }

                        if (shouldThrottleMiscCompaction(proc, procState, requestedAction)) {

                            ++mProcCompactionsMiscThrottled;

                            return;

                        }

                        rssBefore = mProcessDependencies.getRss(pid);

                        if (shouldRssThrottleCompaction(requestedAction, pid, name, rssBefore)) {

                            ++mProcCompactionsRSSThrottled;

                            return;

                        }

                    } else {
@@ -1502,6 +1548,7 @@ public final class CachedAppOptimizer { 
                    try {

                        Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER,

                                "Compact " + action + ": " + name);

                        ++mProcCompactionsPerformed;

                        long zramFreeKbBefore = Debug.getZramFreeKb();

                        mProcessDependencies.performCompaction(action, pid);

                        long[] rssAfter = mProcessDependencies.getRss(pid);
@@ -1553,6 +1600,7 @@ public final class CachedAppOptimizer { 
                    break;

                }

                case COMPACT_SYSTEM_MSG: {

                    ++mSystemCompactionsPerformed;

                    Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "compactSystem");

                    compactSystem();

                    Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);