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

Commit a6a87acf authored by Edgar Arriaga's avatar Edgar Arriaga
Browse files

Avoid compacting when app has foreground activities 

As those processes will likely need to execute code
as soon as screen is unlocked and trigger unlocked
and this would also potentially mitigates situations
where process starts from Cached state which triggers
a during compaction during its startup

Bug: 227494533
Test: Manual
Change-Id: I82e501fbab130ec4b272e310d09d37c5ac944675
parent 33b1957c

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

+55 −45
Original line number Diff line number Diff line
@@ -479,19 +479,33 @@ public final class CachedAppOptimizer { 
    @GuardedBy("mProcLock")

    void compactAppSome(ProcessRecord app, boolean force) {

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_SOME);

        compactApp(app, force, "some");

    }



    // This method returns true only if requirements are met. Note, that requirements are different

    // from throttles applied at the time a compaction is trying to be executed in the sense that

    // these are not subject to change dependent on time or memory as throttles usually do.

    @GuardedBy("mProcLock")

    boolean meetsCompactionRequirements(ProcessRecord proc) {

        if (mAm.mInternal.isPendingTopUid(proc.uid)) {

            // In case the OOM Adjust has not yet been propagated we see if this is

            // pending on becoming top app in which case we should not compact.

            if (DEBUG_COMPACTION) {

            Slog.d(TAG_AM, " compactAppSome requested for " + app.processName + " force: " + force);

                Slog.d(TAG_AM, "Skip compaction since UID is active for  " + proc.processName);

            }

        if (force || !app.mOptRecord.hasPendingCompact()) {

            Trace.instantForTrack(Trace.TRACE_TAG_ACTIVITY_MANAGER, ATRACE_COMPACTION_TRACK,

                    "compactAppSome " + app.processName != null ? app.processName : "");

            app.mOptRecord.setHasPendingCompact(true);

            app.mOptRecord.setForceCompact(force);

            mPendingCompactionProcesses.add(app);

            mCompactionHandler.sendMessage(

                    mCompactionHandler.obtainMessage(

                    COMPACT_PROCESS_MSG, app.mState.getSetAdj(), app.mState.getSetProcState()));

            return false;

        }



        if (proc.mState.hasForegroundActivities()) {

            if (DEBUG_COMPACTION) {

                Slog.e(TAG_AM,

                        "Skip compaction as process " + proc.processName

                                + " has foreground activities");

            }

            return false;

        }



        return true;

    }



    @GuardedBy("mProcLock")
@@ -508,19 +522,7 @@ public final class CachedAppOptimizer { 
        // Apply OOM adj score throttle for Full App Compaction.

        if (force || oomAdjEnteredCached) {

            app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_FULL);

            if (!app.mOptRecord.hasPendingCompact()) {

                Trace.instantForTrack(Trace.TRACE_TAG_ACTIVITY_MANAGER, ATRACE_COMPACTION_TRACK,

                        "compactAppFull " + app.processName != null ? app.processName : "");

                app.mOptRecord.setHasPendingCompact(true);

                app.mOptRecord.setForceCompact(force);

                mPendingCompactionProcesses.add(app);

                mCompactionHandler.sendMessage(mCompactionHandler.obtainMessage(

                        COMPACT_PROCESS_MSG, app.mState.getSetAdj(), app.mState.getSetProcState()));

            } else if (DEBUG_COMPACTION) {

                Slog.d(TAG_AM,

                        " compactAppFull Skipped for " + app.processName

                                + " since it has a pending compact");

            }

            compactApp(app, force, "Full");

        } else {

            if (DEBUG_COMPACTION) {

                Slog.d(TAG_AM, "Skipping full compaction for " + app.processName
@@ -533,15 +535,34 @@ public final class CachedAppOptimizer { 
    @GuardedBy("mProcLock")

    void compactAppPersistent(ProcessRecord app) {

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_PERSISTENT);

        if (!app.mOptRecord.hasPendingCompact()) {

        compactApp(app, false, "Persistent");

    }



    @GuardedBy("mProcLock")

    boolean compactApp(ProcessRecord app, boolean force, String compactRequestType) {

        if (!app.mOptRecord.hasPendingCompact() && meetsCompactionRequirements(app)) {

            final String processName = (app.processName != null ? app.processName : "");

            if (DEBUG_COMPACTION) {

                Slog.d(TAG_AM, "compactApp " + compactRequestType + " " + processName);

            }

            Trace.instantForTrack(Trace.TRACE_TAG_ACTIVITY_MANAGER, ATRACE_COMPACTION_TRACK,

                    "compactAppPersistent " + app.processName != null ? app.processName : "");

                    "compactApp " + compactRequestType + " " + processName);

            app.mOptRecord.setHasPendingCompact(true);

            app.mOptRecord.setForceCompact(force);

            mPendingCompactionProcesses.add(app);

            mCompactionHandler.sendMessage(

                    mCompactionHandler.obtainMessage(

            mCompactionHandler.sendMessage(mCompactionHandler.obtainMessage(

                    COMPACT_PROCESS_MSG, app.mState.getCurAdj(), app.mState.getSetProcState()));

            return true;

        }



        if (DEBUG_COMPACTION) {

            Slog.d(TAG_AM,

                    " compactApp Skipped for " + app.processName

                            + " pendingCompact= " + app.mOptRecord.hasPendingCompact()

                            + " meetsCompactionRequirements=" + meetsCompactionRequirements(app)

                            + ". Requested compact: " + app.mOptRecord.getReqCompactAction());

        }

        return false;

    }



    @GuardedBy("mProcLock")
@@ -553,15 +574,7 @@ public final class CachedAppOptimizer { 
    @GuardedBy("mProcLock")

    void compactAppBfgs(ProcessRecord app) {

        app.mOptRecord.setReqCompactAction(COMPACT_PROCESS_BFGS);

        if (!app.mOptRecord.hasPendingCompact()) {

            Trace.instantForTrack(Trace.TRACE_TAG_ACTIVITY_MANAGER, ATRACE_COMPACTION_TRACK,

                    "compactAppBfgs " + app.processName != null ? app.processName : "");

            app.mOptRecord.setHasPendingCompact(true);

            mPendingCompactionProcesses.add(app);

            mCompactionHandler.sendMessage(

                    mCompactionHandler.obtainMessage(

                    COMPACT_PROCESS_MSG, app.mState.getCurAdj(), app.mState.getSetProcState()));

        }

        compactApp(app, false, " Bfgs");

    }



    @GuardedBy("mProcLock")
@@ -572,6 +585,9 @@ public final class CachedAppOptimizer { 


    void compactAllSystem() {

        if (useCompaction()) {

            if (DEBUG_COMPACTION) {

                Slog.d(TAG_AM, "compactAllSystem");

            }

            Trace.instantForTrack(

                    Trace.TRACE_TAG_ACTIVITY_MANAGER, ATRACE_COMPACTION_TRACK, "compactAllSystem");

            mCompactionHandler.sendMessage(mCompactionHandler.obtainMessage(
@@ -1175,13 +1191,13 @@ public final class CachedAppOptimizer { 
            cancelCompaction();

        }



        // Perform a minor compaction when a perceptible app becomes the prev/home app

        // Perform a major compaction when any app enters cached

        if (oldAdj <= ProcessList.PERCEPTIBLE_APP_ADJ

                && (newAdj == ProcessList.PREVIOUS_APP_ADJ || newAdj == ProcessList.HOME_APP_ADJ)) {

            // Perform a minor compaction when a perceptible app becomes the prev/home app

            compactAppSome(app, false);

        } else if (newAdj >= ProcessList.CACHED_APP_MIN_ADJ

                && newAdj <= ProcessList.CACHED_APP_MAX_ADJ) {

            // Perform a major compaction when any app enters cached

            compactAppFull(app, false);

        }

    }
@@ -1241,12 +1257,6 @@ public final class CachedAppOptimizer { 


        private boolean shouldOomAdjThrottleCompaction(ProcessRecord proc, int action) {

            final String name = proc.processName;

            if (mAm.mInternal.isPendingTopUid(proc.uid)) {

                // In case the OOM Adjust has not yet been propagated we see if this is

                // pending on becoming top app in which case we should not compact.

                Slog.e(TAG_AM, "Skip compaction since UID is active for  " + name);

                return true;

            }



            // don't compact if the process has returned to perceptible

            // and this is only a cached/home/prev compaction

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

+15 −14
Original line number Diff line number Diff line
@@ -2563,8 +2563,9 @@ public class OomAdjuster { 
            // reminder: here, setAdj is previous state, curAdj is upcoming state

            if (state.getCurAdj() != state.getSetAdj()) {

                mCachedAppOptimizer.onOomAdjustChanged(state.getSetAdj(), state.getCurAdj(), app);

            } else if (mService.mWakefulness.get() != PowerManagerInternal.WAKEFULNESS_AWAKE

                    && state.getSetAdj() < ProcessList.FOREGROUND_APP_ADJ

            } else if (mService.mWakefulness.get() != PowerManagerInternal.WAKEFULNESS_AWAKE) {

                // See if we can compact persistent and bfgs services now that screen is off

                if (state.getSetAdj() < ProcessList.FOREGROUND_APP_ADJ

                        && !state.isRunningRemoteAnimation()

                        // Because these can fire independent of oom_adj/procstate changes, we need

                        // to throttle the actual dispatch of these requests in addition to the
@@ -2572,13 +2573,13 @@ public class OomAdjuster { 
                        // and in CachedAppOptimizer.

                        && mCachedAppOptimizer.shouldCompactPersistent(app, now)) {

                    mCachedAppOptimizer.compactAppPersistent(app);

            } else if (mService.mWakefulness.get() != PowerManagerInternal.WAKEFULNESS_AWAKE

                    && state.getCurProcState()

                } else if (state.getCurProcState()

                                == ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE

                        && mCachedAppOptimizer.shouldCompactBFGS(app, now)) {

                    mCachedAppOptimizer.compactAppBfgs(app);

                }

            }

        }



        if (state.getCurAdj() != state.getSetAdj()) {

            ProcessList.setOomAdj(app.getPid(), app.uid, state.getCurAdj());