diff --git a/services/core/java/com/android/server/am/ActivityManagerConstants.java b/services/core/java/com/android/server/am/ActivityManagerConstants.java index 16fe121fecb77..003f7f0d88fb7 100644 --- a/services/core/java/com/android/server/am/ActivityManagerConstants.java +++ b/services/core/java/com/android/server/am/ActivityManagerConstants.java @@ -248,6 +248,18 @@ final class ActivityManagerConstants extends ContentObserver { */ private static final String KEY_MAX_PHANTOM_PROCESSES = "max_phantom_processes"; + /** + * Enables proactive killing of cached apps + */ + private static final String KEY_PROACTIVE_KILLS_ENABLED = "proactive_kills_enabled"; + + /** + * Trim LRU cached app when swap falls below this minimum percentage. + * + * Depends on KEY_PROACTIVE_KILLS_ENABLED + */ + private static final String KEY_LOW_SWAP_THRESHOLD_PERCENT = "low_swap_threshold_percent"; + /** * Default value for mFlagBackgroundActivityStartsEnabled if not explicitly set in * Settings.Global. This allows it to be set experimentally unless it has been @@ -874,6 +886,10 @@ final class ActivityManagerConstants extends ContentObserver { */ private static final long DEFAULT_MIN_ASSOC_LOG_DURATION = 5 * 60 * 1000; // 5 mins + private static final boolean DEFAULT_PROACTIVE_KILLS_ENABLED = false; + + private static final float DEFAULT_LOW_SWAP_THRESHOLD_PERCENT = 0.10f; + private static final String KEY_MIN_ASSOC_LOG_DURATION = "min_assoc_log_duration"; public static long MIN_ASSOC_LOG_DURATION = DEFAULT_MIN_ASSOC_LOG_DURATION; @@ -904,6 +920,8 @@ final class ActivityManagerConstants extends ContentObserver { public static boolean BINDER_HEAVY_HITTER_AUTO_SAMPLER_ENABLED; public static int BINDER_HEAVY_HITTER_AUTO_SAMPLER_BATCHSIZE; public static float BINDER_HEAVY_HITTER_AUTO_SAMPLER_THRESHOLD; + public static boolean PROACTIVE_KILLS_ENABLED = DEFAULT_PROACTIVE_KILLS_ENABLED; + public static float LOW_SWAP_THRESHOLD_PERCENT = DEFAULT_LOW_SWAP_THRESHOLD_PERCENT; private final OnPropertiesChangedListener mOnDeviceConfigChangedListener = new OnPropertiesChangedListener() { @@ -1040,6 +1058,12 @@ final class ActivityManagerConstants extends ContentObserver { case KEY_MAX_SERVICE_CONNECTIONS_PER_PROCESS: updateMaxServiceConnectionsPerProcess(); break; + case KEY_PROACTIVE_KILLS_ENABLED: + updateProactiveKillsEnabled(); + break; + case KEY_LOW_SWAP_THRESHOLD_PERCENT: + updateLowSwapThresholdPercent(); + break; default: break; } @@ -1660,6 +1684,20 @@ final class ActivityManagerConstants extends ContentObserver { CUR_TRIM_CACHED_PROCESSES = (MAX_CACHED_PROCESSES-rawMaxEmptyProcesses)/3; } + private void updateProactiveKillsEnabled() { + PROACTIVE_KILLS_ENABLED = DeviceConfig.getBoolean( + DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, + KEY_PROACTIVE_KILLS_ENABLED, + DEFAULT_PROACTIVE_KILLS_ENABLED); + } + + private void updateLowSwapThresholdPercent() { + LOW_SWAP_THRESHOLD_PERCENT = DeviceConfig.getFloat( + DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, + KEY_LOW_SWAP_THRESHOLD_PERCENT, + DEFAULT_LOW_SWAP_THRESHOLD_PERCENT); + } + private void updateMinAssocLogDuration() { MIN_ASSOC_LOG_DURATION = DeviceConfig.getLong( DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_MIN_ASSOC_LOG_DURATION, @@ -1860,6 +1898,10 @@ final class ActivityManagerConstants extends ContentObserver { pw.print("="); pw.println(mNetworkAccessTimeoutMs); pw.print(" "); pw.print(KEY_MAX_SERVICE_CONNECTIONS_PER_PROCESS); pw.print("="); pw.println(mMaxServiceConnectionsPerProcess); + pw.print(" "); pw.print(KEY_PROACTIVE_KILLS_ENABLED); + pw.print("="); pw.println(PROACTIVE_KILLS_ENABLED); + pw.print(" "); pw.print(KEY_LOW_SWAP_THRESHOLD_PERCENT); + pw.print("="); pw.println(LOW_SWAP_THRESHOLD_PERCENT); pw.println(); if (mOverrideMaxCachedProcesses >= 0) { diff --git a/services/core/java/com/android/server/am/CachedAppOptimizer.java b/services/core/java/com/android/server/am/CachedAppOptimizer.java index 2d7b0dc7b536d..e34cd12d0ec39 100644 --- a/services/core/java/com/android/server/am/CachedAppOptimizer.java +++ b/services/core/java/com/android/server/am/CachedAppOptimizer.java @@ -845,7 +845,7 @@ public final class CachedAppOptimizer { /** * Retrieves the free swap percentage. */ - static private native double getFreeSwapPercent(); + static native double getFreeSwapPercent(); /** * Retrieves the total used physical ZRAM diff --git a/services/core/java/com/android/server/am/OomAdjuster.java b/services/core/java/com/android/server/am/OomAdjuster.java index 68e5a5df95629..eb2b7d493251e 100644 --- a/services/core/java/com/android/server/am/OomAdjuster.java +++ b/services/core/java/com/android/server/am/OomAdjuster.java @@ -1118,6 +1118,12 @@ public class OomAdjuster { private long mNextNoKillDebugMessageTime; + private double mLastFreeSwapPercent = 1.00; + + private static double getFreeSwapPercent() { + return CachedAppOptimizer.getFreeSwapPercent(); + } + @GuardedBy({"mService", "mProcLock"}) private boolean updateAndTrimProcessLSP(final long now, final long nowElapsed, final long oldTime, final ActiveUids activeUids, @OomAdjReason int oomAdjReason) { @@ -1142,6 +1148,11 @@ public class OomAdjuster { int numEmpty = 0; int numTrimming = 0; + boolean proactiveKillsEnabled = mConstants.PROACTIVE_KILLS_ENABLED; + double lowSwapThresholdPercent = mConstants.LOW_SWAP_THRESHOLD_PERCENT; + double freeSwapPercent = proactiveKillsEnabled ? getFreeSwapPercent() : 1.00; + ProcessRecord lruCachedApp = null; + for (int i = numLru - 1; i >= 0; i--) { ProcessRecord app = lruList.get(i); final ProcessStateRecord state = app.mState; @@ -1179,6 +1190,8 @@ public class OomAdjuster { ApplicationExitInfo.REASON_OTHER, ApplicationExitInfo.SUBREASON_TOO_MANY_CACHED, true); + } else if (proactiveKillsEnabled) { + lruCachedApp = app; } break; case PROCESS_STATE_CACHED_EMPTY: @@ -1198,6 +1211,8 @@ public class OomAdjuster { ApplicationExitInfo.REASON_OTHER, ApplicationExitInfo.SUBREASON_TOO_MANY_EMPTY, true); + } else if (proactiveKillsEnabled) { + lruCachedApp = app; } } break; @@ -1229,6 +1244,20 @@ public class OomAdjuster { } } + if (proactiveKillsEnabled // Proactive kills enabled? + && doKillExcessiveProcesses // Should kill excessive processes? + && freeSwapPercent < lowSwapThresholdPercent // Swap below threshold? + && lruCachedApp != null // If no cached app, let LMKD decide + // If swap is non-decreasing, give reclaim a chance to catch up + && freeSwapPercent < mLastFreeSwapPercent) { + lruCachedApp.killLocked("swap low and too many cached", + ApplicationExitInfo.REASON_OTHER, + ApplicationExitInfo.SUBREASON_TOO_MANY_CACHED, + true); + } + + mLastFreeSwapPercent = freeSwapPercent; + return mService.mAppProfiler.updateLowMemStateLSP(numCached, numEmpty, numTrimming); }