/* * 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.am; import static android.os.Process.THREAD_PRIORITY_FOREGROUND; import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_COMPACTION; import static com.android.server.am.ActivityManagerDebugConfig.DEBUG_FREEZER; import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM; import android.app.ActivityManager; import android.app.ActivityThread; import android.os.Debug; import android.os.Handler; import android.os.Message; import android.os.Process; import android.os.SystemClock; import android.os.Trace; import android.provider.DeviceConfig; import android.provider.DeviceConfig.OnPropertiesChangedListener; import android.provider.DeviceConfig.Properties; import android.provider.Settings; import android.text.TextUtils; import android.util.EventLog; import android.util.Slog; import com.android.internal.annotations.GuardedBy; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.util.FrameworkStatsLog; import com.android.server.ServiceThread; import java.io.FileOutputStream; import java.io.FileReader; import java.io.IOException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.Map; import java.util.Random; import java.util.Set; public final class CachedAppOptimizer { // Flags stored in the DeviceConfig API. @VisibleForTesting static final String KEY_USE_COMPACTION = "use_compaction"; @VisibleForTesting static final String KEY_USE_FREEZER = "use_freezer"; @VisibleForTesting static final String KEY_COMPACT_ACTION_1 = "compact_action_1"; @VisibleForTesting static final String KEY_COMPACT_ACTION_2 = "compact_action_2"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_1 = "compact_throttle_1"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_2 = "compact_throttle_2"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_3 = "compact_throttle_3"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_4 = "compact_throttle_4"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_5 = "compact_throttle_5"; @VisibleForTesting static final String KEY_COMPACT_THROTTLE_6 = "compact_throttle_6"; @VisibleForTesting static final String KEY_COMPACT_STATSD_SAMPLE_RATE = "compact_statsd_sample_rate"; @VisibleForTesting static final String KEY_FREEZER_STATSD_SAMPLE_RATE = "freeze_statsd_sample_rate"; @VisibleForTesting static final String KEY_COMPACT_FULL_RSS_THROTTLE_KB = "compact_full_rss_throttle_kb"; @VisibleForTesting static final String KEY_COMPACT_FULL_DELTA_RSS_THROTTLE_KB = "compact_full_delta_rss_throttle_kb"; @VisibleForTesting static final String KEY_COMPACT_PROC_STATE_THROTTLE = "compact_proc_state_throttle"; // Phenotype sends int configurations and we map them to the strings we'll use on device, // preventing a weird string value entering the kernel. private static final int COMPACT_ACTION_FILE_FLAG = 1; private static final int COMPACT_ACTION_ANON_FLAG = 2; private static final int COMPACT_ACTION_FULL_FLAG = 3; private static final int COMPACT_ACTION_NONE_FLAG = 4; private static final String COMPACT_ACTION_NONE = ""; private static final String COMPACT_ACTION_FILE = "file"; private static final String COMPACT_ACTION_ANON = "anon"; private static final String COMPACT_ACTION_FULL = "all"; // Defaults for phenotype flags. @VisibleForTesting static final Boolean DEFAULT_USE_COMPACTION = false; @VisibleForTesting static final Boolean DEFAULT_USE_FREEZER = false; @VisibleForTesting static final int DEFAULT_COMPACT_ACTION_1 = COMPACT_ACTION_FILE_FLAG; @VisibleForTesting static final int DEFAULT_COMPACT_ACTION_2 = COMPACT_ACTION_FULL_FLAG; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_1 = 5_000; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_2 = 10_000; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_3 = 500; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_4 = 10_000; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_5 = 10 * 60 * 1000; @VisibleForTesting static final long DEFAULT_COMPACT_THROTTLE_6 = 10 * 60 * 1000; // The sampling rate to push app compaction events into statsd for upload. @VisibleForTesting static final float DEFAULT_STATSD_SAMPLE_RATE = 0.1f; @VisibleForTesting static final long DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB = 12_000L; @VisibleForTesting static final long DEFAULT_COMPACT_FULL_DELTA_RSS_THROTTLE_KB = 8_000L; // Format of this string should be a comma separated list of integers. @VisibleForTesting static final String DEFAULT_COMPACT_PROC_STATE_THROTTLE = String.valueOf(ActivityManager.PROCESS_STATE_RECEIVER); @VisibleForTesting interface PropertyChangedCallbackForTest { void onPropertyChanged(); } private PropertyChangedCallbackForTest mTestCallback; // This interface is for functions related to the Process object that need a different // implementation in the tests as we are not creating real processes when testing compaction. @VisibleForTesting interface ProcessDependencies { long[] getRss(int pid); void performCompaction(String action, int pid) throws IOException; } // Handler constants. static final int COMPACT_PROCESS_SOME = 1; static final int COMPACT_PROCESS_FULL = 2; static final int COMPACT_PROCESS_PERSISTENT = 3; static final int COMPACT_PROCESS_BFGS = 4; static final int COMPACT_PROCESS_MSG = 1; static final int COMPACT_SYSTEM_MSG = 2; static final int SET_FROZEN_PROCESS_MSG = 3; static final int REPORT_UNFREEZE_MSG = 4; //TODO:change this static definition into a configurable flag. static final int FREEZE_TIMEOUT_MS = 500; static final int DO_FREEZE = 1; static final int REPORT_UNFREEZE = 2; /** * This thread must be moved to the system background cpuset. * If that doesn't happen, it's probably going to draw a lot of power. * However, this has to happen after the first updateOomAdjLocked, because * that will wipe out the cpuset assignment for system_server threads. * Accordingly, this is in the AMS constructor. */ final ServiceThread mCachedAppOptimizerThread; private final ArrayList mPendingCompactionProcesses = new ArrayList(); private final ActivityManagerService mAm; private final OnPropertiesChangedListener mOnFlagsChangedListener = new OnPropertiesChangedListener() { @Override public void onPropertiesChanged(Properties properties) { synchronized (mPhenotypeFlagLock) { for (String name : properties.getKeyset()) { if (KEY_USE_COMPACTION.equals(name)) { updateUseCompaction(); } else if (KEY_COMPACT_ACTION_1.equals(name) || KEY_COMPACT_ACTION_2.equals(name)) { updateCompactionActions(); } else if (KEY_COMPACT_THROTTLE_1.equals(name) || KEY_COMPACT_THROTTLE_2.equals(name) || KEY_COMPACT_THROTTLE_3.equals(name) || KEY_COMPACT_THROTTLE_4.equals(name)) { updateCompactionThrottles(); } else if (KEY_COMPACT_STATSD_SAMPLE_RATE.equals(name)) { updateCompactStatsdSampleRate(); } else if (KEY_FREEZER_STATSD_SAMPLE_RATE.equals(name)) { updateFreezerStatsdSampleRate(); } else if (KEY_COMPACT_FULL_RSS_THROTTLE_KB.equals(name)) { updateFullRssThrottle(); } else if (KEY_COMPACT_FULL_DELTA_RSS_THROTTLE_KB.equals(name)) { updateFullDeltaRssThrottle(); } else if (KEY_COMPACT_PROC_STATE_THROTTLE.equals(name)) { updateProcStateThrottle(); } } } if (mTestCallback != null) { mTestCallback.onPropertyChanged(); } } }; private final Object mPhenotypeFlagLock = new Object(); // Configured by phenotype. Updates from the server take effect immediately. @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile String mCompactActionSome = compactActionIntToString(DEFAULT_COMPACT_ACTION_1); @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile String mCompactActionFull = compactActionIntToString(DEFAULT_COMPACT_ACTION_2); @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottleSomeSome = DEFAULT_COMPACT_THROTTLE_1; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottleSomeFull = DEFAULT_COMPACT_THROTTLE_2; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottleFullSome = DEFAULT_COMPACT_THROTTLE_3; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottleFullFull = DEFAULT_COMPACT_THROTTLE_4; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottleBFGS = DEFAULT_COMPACT_THROTTLE_5; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mCompactThrottlePersistent = DEFAULT_COMPACT_THROTTLE_6; @GuardedBy("mPhenotypeFlagLock") private volatile boolean mUseCompaction = DEFAULT_USE_COMPACTION; private volatile boolean mUseFreezer = DEFAULT_USE_FREEZER; private final Random mRandom = new Random(); @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile float mCompactStatsdSampleRate = DEFAULT_STATSD_SAMPLE_RATE; @VisibleForTesting volatile float mFreezerStatsdSampleRate = DEFAULT_STATSD_SAMPLE_RATE; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mFullAnonRssThrottleKb = DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting volatile long mFullDeltaRssThrottleKb = DEFAULT_COMPACT_FULL_DELTA_RSS_THROTTLE_KB; @GuardedBy("mPhenotypeFlagLock") @VisibleForTesting final Set mProcStateThrottle; // Handler on which compaction runs. @VisibleForTesting Handler mCompactionHandler; private Handler mFreezeHandler; // Maps process ID to last compaction statistics for processes that we've fully compacted. Used // when evaluating throttles that we only consider for "full" compaction, so we don't store // data for "some" compactions. Uses LinkedHashMap to ensure insertion order is kept and // facilitate removal of the oldest entry. @VisibleForTesting LinkedHashMap mLastCompactionStats = new LinkedHashMap() { @Override protected boolean removeEldestEntry(Map.Entry eldest) { return size() > 100; } }; private int mSomeCompactionCount; private int mFullCompactionCount; private int mPersistentCompactionCount; private int mBfgsCompactionCount; private final ProcessDependencies mProcessDependencies; public CachedAppOptimizer(ActivityManagerService am) { this(am, null, new DefaultProcessDependencies()); } @VisibleForTesting CachedAppOptimizer(ActivityManagerService am, PropertyChangedCallbackForTest callback, ProcessDependencies processDependencies) { mAm = am; mCachedAppOptimizerThread = new ServiceThread("CachedAppOptimizerThread", THREAD_PRIORITY_FOREGROUND, true); mProcStateThrottle = new HashSet<>(); mProcessDependencies = processDependencies; mTestCallback = callback; } /** * Reads phenotype config to determine whether app compaction is enabled or not and * starts the background thread if necessary. */ public void init() { DeviceConfig.addOnPropertiesChangedListener(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, ActivityThread.currentApplication().getMainExecutor(), mOnFlagsChangedListener); synchronized (mPhenotypeFlagLock) { updateUseCompaction(); updateCompactionActions(); updateCompactionThrottles(); updateCompactStatsdSampleRate(); updateFreezerStatsdSampleRate(); updateFullRssThrottle(); updateFullDeltaRssThrottle(); updateProcStateThrottle(); updateUseFreezer(); } Process.setThreadGroupAndCpuset(mCachedAppOptimizerThread.getThreadId(), Process.THREAD_GROUP_SYSTEM); } /** * Returns whether compaction is enabled. */ public boolean useCompaction() { synchronized (mPhenotypeFlagLock) { return mUseCompaction; } } /** * Returns whether freezer is enabled. */ public boolean useFreezer() { synchronized (mPhenotypeFlagLock) { return mUseFreezer; } } @GuardedBy("mAm") void dump(PrintWriter pw) { pw.println("CachedAppOptimizer settings"); synchronized (mPhenotypeFlagLock) { pw.println(" " + KEY_USE_COMPACTION + "=" + mUseCompaction); pw.println(" " + KEY_COMPACT_ACTION_1 + "=" + mCompactActionSome); pw.println(" " + KEY_COMPACT_ACTION_2 + "=" + mCompactActionFull); pw.println(" " + KEY_COMPACT_THROTTLE_1 + "=" + mCompactThrottleSomeSome); pw.println(" " + KEY_COMPACT_THROTTLE_2 + "=" + mCompactThrottleSomeFull); pw.println(" " + KEY_COMPACT_THROTTLE_3 + "=" + mCompactThrottleFullSome); pw.println(" " + KEY_COMPACT_THROTTLE_4 + "=" + mCompactThrottleFullFull); pw.println(" " + KEY_COMPACT_THROTTLE_5 + "=" + mCompactThrottleBFGS); pw.println(" " + KEY_COMPACT_THROTTLE_6 + "=" + mCompactThrottlePersistent); pw.println(" " + KEY_COMPACT_STATSD_SAMPLE_RATE + "=" + mCompactStatsdSampleRate); pw.println(" " + KEY_COMPACT_FULL_RSS_THROTTLE_KB + "=" + mFullAnonRssThrottleKb); pw.println(" " + KEY_COMPACT_FULL_DELTA_RSS_THROTTLE_KB + "=" + mFullDeltaRssThrottleKb); pw.println(" " + KEY_COMPACT_PROC_STATE_THROTTLE + "=" + Arrays.toString(mProcStateThrottle.toArray(new Integer[0]))); pw.println(" " + mSomeCompactionCount + " some, " + mFullCompactionCount + " full, " + mPersistentCompactionCount + " persistent, " + mBfgsCompactionCount + " BFGS compactions."); pw.println(" Tracking last compaction stats for " + mLastCompactionStats.size() + " processes."); pw.println(" " + KEY_USE_FREEZER + "=" + mUseFreezer); pw.println(" " + KEY_FREEZER_STATSD_SAMPLE_RATE + "=" + mFreezerStatsdSampleRate); if (DEBUG_COMPACTION) { for (Map.Entry entry : mLastCompactionStats.entrySet()) { int pid = entry.getKey(); LastCompactionStats stats = entry.getValue(); pw.println(" " + pid + ": " + Arrays.toString(stats.getRssAfterCompaction())); } } } } @GuardedBy("mAm") void compactAppSome(ProcessRecord app) { app.reqCompactAction = COMPACT_PROCESS_SOME; mPendingCompactionProcesses.add(app); mCompactionHandler.sendMessage( mCompactionHandler.obtainMessage( COMPACT_PROCESS_MSG, app.setAdj, app.setProcState)); } @GuardedBy("mAm") void compactAppFull(ProcessRecord app) { app.reqCompactAction = COMPACT_PROCESS_FULL; mPendingCompactionProcesses.add(app); mCompactionHandler.sendMessage( mCompactionHandler.obtainMessage( COMPACT_PROCESS_MSG, app.setAdj, app.setProcState)); } @GuardedBy("mAm") void compactAppPersistent(ProcessRecord app) { app.reqCompactAction = COMPACT_PROCESS_PERSISTENT; mPendingCompactionProcesses.add(app); mCompactionHandler.sendMessage( mCompactionHandler.obtainMessage( COMPACT_PROCESS_MSG, app.curAdj, app.setProcState)); } @GuardedBy("mAm") boolean shouldCompactPersistent(ProcessRecord app, long now) { return (app.lastCompactTime == 0 || (now - app.lastCompactTime) > mCompactThrottlePersistent); } @GuardedBy("mAm") void compactAppBfgs(ProcessRecord app) { app.reqCompactAction = COMPACT_PROCESS_BFGS; mPendingCompactionProcesses.add(app); mCompactionHandler.sendMessage( mCompactionHandler.obtainMessage( COMPACT_PROCESS_MSG, app.curAdj, app.setProcState)); } @GuardedBy("mAm") boolean shouldCompactBFGS(ProcessRecord app, long now) { return (app.lastCompactTime == 0 || (now - app.lastCompactTime) > mCompactThrottleBFGS); } @GuardedBy("mAm") void compactAllSystem() { if (mUseCompaction) { mCompactionHandler.sendMessage(mCompactionHandler.obtainMessage( COMPACT_SYSTEM_MSG)); } } private native void compactSystem(); /** * Reads the flag value from DeviceConfig to determine whether app compaction * should be enabled, and starts the freeze/compaction thread if needed. */ @GuardedBy("mPhenotypeFlagLock") private void updateUseCompaction() { mUseCompaction = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_USE_COMPACTION, DEFAULT_USE_COMPACTION); if (mUseCompaction) { if (!mCachedAppOptimizerThread.isAlive()) { mCachedAppOptimizerThread.start(); } mCompactionHandler = new MemCompactionHandler(); } } /** * Determines whether the freezer is correctly supported by this system */ public static boolean isFreezerSupported() { boolean supported = false; FileReader fr = null; try { fr = new FileReader("/dev/freezer/frozen/freezer.killable"); int i = fr.read(); if ((char) i == '1') { supported = true; } else { Slog.w(TAG_AM, "Freezer killability is turned off, disabling freezer"); } } catch (java.io.FileNotFoundException e) { Slog.d(TAG_AM, "Freezer.killable not present, disabling freezer"); } catch (Exception e) { Slog.d(TAG_AM, "Unable to read freezer.killable, disabling freezer: " + e.toString()); } if (fr != null) { try { fr.close(); } catch (java.io.IOException e) { Slog.e(TAG_AM, "Exception closing freezer.killable: " + e.toString()); } } return supported; } /** * Reads the flag value from DeviceConfig to determine whether app freezer * should be enabled, and starts the freeze/compaction thread if needed. */ @GuardedBy("mPhenotypeFlagLock") private void updateUseFreezer() { final String configOverride = Settings.Global.getString(mAm.mContext.getContentResolver(), Settings.Global.CACHED_APPS_FREEZER_ENABLED); if ("disabled".equals(configOverride)) { mUseFreezer = false; } else if ("enabled".equals(configOverride) || DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER_NATIVE_BOOT, KEY_USE_FREEZER, DEFAULT_USE_FREEZER)) { mUseFreezer = isFreezerSupported(); } if (mUseFreezer) { Slog.d(TAG_AM, "Freezer enabled"); if (!mCachedAppOptimizerThread.isAlive()) { mCachedAppOptimizerThread.start(); } mFreezeHandler = new FreezeHandler(); } } @GuardedBy("mPhenotypeFlagLock") private void updateCompactionActions() { int compactAction1 = DeviceConfig.getInt(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_ACTION_1, DEFAULT_COMPACT_ACTION_1); int compactAction2 = DeviceConfig.getInt(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_ACTION_2, DEFAULT_COMPACT_ACTION_2); mCompactActionSome = compactActionIntToString(compactAction1); mCompactActionFull = compactActionIntToString(compactAction2); } @GuardedBy("mPhenotypeFlagLock") private void updateCompactionThrottles() { boolean useThrottleDefaults = false; String throttleSomeSomeFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_1); String throttleSomeFullFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_2); String throttleFullSomeFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_3); String throttleFullFullFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_4); String throttleBFGSFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_5); String throttlePersistentFlag = DeviceConfig.getProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_THROTTLE_6); if (TextUtils.isEmpty(throttleSomeSomeFlag) || TextUtils.isEmpty(throttleSomeFullFlag) || TextUtils.isEmpty(throttleFullSomeFlag) || TextUtils.isEmpty(throttleFullFullFlag) || TextUtils.isEmpty(throttleBFGSFlag) || TextUtils.isEmpty(throttlePersistentFlag)) { // Set defaults for all if any are not set. useThrottleDefaults = true; } else { try { mCompactThrottleSomeSome = Integer.parseInt(throttleSomeSomeFlag); mCompactThrottleSomeFull = Integer.parseInt(throttleSomeFullFlag); mCompactThrottleFullSome = Integer.parseInt(throttleFullSomeFlag); mCompactThrottleFullFull = Integer.parseInt(throttleFullFullFlag); mCompactThrottleBFGS = Integer.parseInt(throttleBFGSFlag); mCompactThrottlePersistent = Integer.parseInt(throttlePersistentFlag); } catch (NumberFormatException e) { useThrottleDefaults = true; } } if (useThrottleDefaults) { mCompactThrottleSomeSome = DEFAULT_COMPACT_THROTTLE_1; mCompactThrottleSomeFull = DEFAULT_COMPACT_THROTTLE_2; mCompactThrottleFullSome = DEFAULT_COMPACT_THROTTLE_3; mCompactThrottleFullFull = DEFAULT_COMPACT_THROTTLE_4; mCompactThrottleBFGS = DEFAULT_COMPACT_THROTTLE_5; mCompactThrottlePersistent = DEFAULT_COMPACT_THROTTLE_6; } } @GuardedBy("mPhenotypeFlagLock") private void updateCompactStatsdSampleRate() { mCompactStatsdSampleRate = DeviceConfig.getFloat(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_STATSD_SAMPLE_RATE, DEFAULT_STATSD_SAMPLE_RATE); mCompactStatsdSampleRate = Math.min(1.0f, Math.max(0.0f, mCompactStatsdSampleRate)); } @GuardedBy("mPhenotypeFlagLock") private void updateFreezerStatsdSampleRate() { mFreezerStatsdSampleRate = DeviceConfig.getFloat(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_FREEZER_STATSD_SAMPLE_RATE, DEFAULT_STATSD_SAMPLE_RATE); mFreezerStatsdSampleRate = Math.min(1.0f, Math.max(0.0f, mFreezerStatsdSampleRate)); } @GuardedBy("mPhenotypeFlagLock") private void updateFullRssThrottle() { mFullAnonRssThrottleKb = DeviceConfig.getLong(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_FULL_RSS_THROTTLE_KB, DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB); // Don't allow negative values. 0 means don't apply the throttle. if (mFullAnonRssThrottleKb < 0) { mFullAnonRssThrottleKb = DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB; } } @GuardedBy("mPhenotypeFlagLock") private void updateFullDeltaRssThrottle() { mFullDeltaRssThrottleKb = DeviceConfig.getLong(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_FULL_DELTA_RSS_THROTTLE_KB, DEFAULT_COMPACT_FULL_DELTA_RSS_THROTTLE_KB); if (mFullDeltaRssThrottleKb < 0) { mFullDeltaRssThrottleKb = DEFAULT_COMPACT_FULL_DELTA_RSS_THROTTLE_KB; } } @GuardedBy("mPhenotypeFlagLock") private void updateProcStateThrottle() { String procStateThrottleString = DeviceConfig.getString( DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, KEY_COMPACT_PROC_STATE_THROTTLE, DEFAULT_COMPACT_PROC_STATE_THROTTLE); if (!parseProcStateThrottle(procStateThrottleString)) { Slog.w(TAG_AM, "Unable to parse app compact proc state throttle \"" + procStateThrottleString + "\" falling back to default."); if (!parseProcStateThrottle(DEFAULT_COMPACT_PROC_STATE_THROTTLE)) { Slog.wtf(TAG_AM, "Unable to parse default app compact proc state throttle " + DEFAULT_COMPACT_PROC_STATE_THROTTLE); } } } private boolean parseProcStateThrottle(String procStateThrottleString) { String[] procStates = TextUtils.split(procStateThrottleString, ","); mProcStateThrottle.clear(); for (String procState : procStates) { try { mProcStateThrottle.add(Integer.parseInt(procState)); } catch (NumberFormatException e) { Slog.e(TAG_AM, "Failed to parse default app compaction proc state: " + procState); return false; } } return true; } @VisibleForTesting static String compactActionIntToString(int action) { switch(action) { case COMPACT_ACTION_NONE_FLAG: return COMPACT_ACTION_NONE; case COMPACT_ACTION_FILE_FLAG: return COMPACT_ACTION_FILE; case COMPACT_ACTION_ANON_FLAG: return COMPACT_ACTION_ANON; case COMPACT_ACTION_FULL_FLAG: return COMPACT_ACTION_FULL; default: return COMPACT_ACTION_NONE; } } @GuardedBy("mAm") void freezeAppAsync(ProcessRecord app) { mFreezeHandler.removeMessages(SET_FROZEN_PROCESS_MSG, app); mFreezeHandler.sendMessageDelayed( mFreezeHandler.obtainMessage( SET_FROZEN_PROCESS_MSG, DO_FREEZE, 0, app), FREEZE_TIMEOUT_MS); } @GuardedBy("mAm") void unfreezeAppLocked(ProcessRecord app) { mFreezeHandler.removeMessages(SET_FROZEN_PROCESS_MSG, app); if (!app.frozen) { if (DEBUG_FREEZER) { Slog.d(TAG_AM, "Skipping unfreeze for process " + app.pid + " " + app.processName + " (not frozen)"); } return; } long freezeTime = app.freezeUnfreezeTime; try { Process.setProcessFrozen(app.pid, app.uid, false); app.freezeUnfreezeTime = SystemClock.uptimeMillis(); app.frozen = false; } catch (Exception e) { Slog.e(TAG_AM, "Unable to unfreeze " + app.pid + " " + app.processName + ". Any related user experience might be hanged."); } if (!app.frozen) { if (DEBUG_FREEZER) { Slog.d(TAG_AM, "sync unfroze " + app.pid + " " + app.processName); } mFreezeHandler.sendMessage( mFreezeHandler.obtainMessage(REPORT_UNFREEZE_MSG, app.pid, (int) Math.min(app.freezeUnfreezeTime - freezeTime, Integer.MAX_VALUE), app.processName)); } } @VisibleForTesting static final class LastCompactionStats { private final long[] mRssAfterCompaction; LastCompactionStats(long[] rss) { mRssAfterCompaction = rss; } long[] getRssAfterCompaction() { return mRssAfterCompaction; } } private final class MemCompactionHandler extends Handler { private MemCompactionHandler() { super(mCachedAppOptimizerThread.getLooper()); } @Override public void handleMessage(Message msg) { switch (msg.what) { case COMPACT_PROCESS_MSG: { long start = SystemClock.uptimeMillis(); ProcessRecord proc; int pid; String action; final String name; int pendingAction, lastCompactAction; long lastCompactTime; LastCompactionStats lastCompactionStats; int lastOomAdj = msg.arg1; int procState = msg.arg2; synchronized (mAm) { proc = mPendingCompactionProcesses.remove(0); pendingAction = proc.reqCompactAction; pid = proc.pid; name = proc.processName; // don't compact if the process has returned to perceptible // and this is only a cached/home/prev compaction if ((pendingAction == COMPACT_PROCESS_SOME || pendingAction == COMPACT_PROCESS_FULL) && (proc.setAdj <= ProcessList.PERCEPTIBLE_APP_ADJ)) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping compaction as process " + name + " is " + "now perceptible."); } return; } lastCompactAction = proc.lastCompactAction; lastCompactTime = proc.lastCompactTime; lastCompactionStats = mLastCompactionStats.get(pid); } if (pid == 0) { // not a real process, either one being launched or one being killed return; } // basic throttling // use the Phenotype flag knobs to determine whether current/prevous // compaction combo should be throtted or not // Note that we explicitly don't take mPhenotypeFlagLock here as the flags // should very seldom change, and taking the risk of using the wrong action is // preferable to taking the lock for every single compaction action. if (lastCompactTime != 0) { if (pendingAction == COMPACT_PROCESS_SOME) { if ((lastCompactAction == COMPACT_PROCESS_SOME && (start - lastCompactTime < mCompactThrottleSomeSome)) || (lastCompactAction == COMPACT_PROCESS_FULL && (start - lastCompactTime < mCompactThrottleSomeFull))) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping some compaction for " + name + ": too soon. throttle=" + mCompactThrottleSomeSome + "/" + mCompactThrottleSomeFull + " last=" + (start - lastCompactTime) + "ms ago"); } return; } } else if (pendingAction == COMPACT_PROCESS_FULL) { if ((lastCompactAction == COMPACT_PROCESS_SOME && (start - lastCompactTime < mCompactThrottleFullSome)) || (lastCompactAction == COMPACT_PROCESS_FULL && (start - lastCompactTime < mCompactThrottleFullFull))) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping full compaction for " + name + ": too soon. throttle=" + mCompactThrottleFullSome + "/" + mCompactThrottleFullFull + " last=" + (start - lastCompactTime) + "ms ago"); } return; } } else if (pendingAction == COMPACT_PROCESS_PERSISTENT) { if (start - lastCompactTime < mCompactThrottlePersistent) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping persistent compaction for " + name + ": too soon. throttle=" + mCompactThrottlePersistent + " last=" + (start - lastCompactTime) + "ms ago"); } return; } } else if (pendingAction == COMPACT_PROCESS_BFGS) { if (start - lastCompactTime < mCompactThrottleBFGS) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping bfgs compaction for " + name + ": too soon. throttle=" + mCompactThrottleBFGS + " last=" + (start - lastCompactTime) + "ms ago"); } return; } } } switch (pendingAction) { case COMPACT_PROCESS_SOME: action = mCompactActionSome; break; // For the time being, treat these as equivalent. case COMPACT_PROCESS_FULL: case COMPACT_PROCESS_PERSISTENT: case COMPACT_PROCESS_BFGS: action = mCompactActionFull; break; default: action = COMPACT_ACTION_NONE; break; } if (COMPACT_ACTION_NONE.equals(action)) { return; } if (mProcStateThrottle.contains(procState)) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping full compaction for process " + name + "; proc state is " + procState); } return; } long[] rssBefore = mProcessDependencies.getRss(pid); long anonRssBefore = rssBefore[2]; if (rssBefore[0] == 0 && rssBefore[1] == 0 && rssBefore[2] == 0 && rssBefore[3] == 0) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping compaction for" + "process " + pid + " with no memory usage. Dead?"); } return; } if (action.equals(COMPACT_ACTION_FULL) || action.equals(COMPACT_ACTION_ANON)) { if (mFullAnonRssThrottleKb > 0L && anonRssBefore < mFullAnonRssThrottleKb) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping full compaction for process " + name + "; anon RSS is too small: " + anonRssBefore + "KB."); } return; } if (lastCompactionStats != null && mFullDeltaRssThrottleKb > 0L) { long[] lastRss = lastCompactionStats.getRssAfterCompaction(); long absDelta = Math.abs(rssBefore[1] - lastRss[1]) + Math.abs(rssBefore[2] - lastRss[2]) + Math.abs(rssBefore[3] - lastRss[3]); if (absDelta <= mFullDeltaRssThrottleKb) { if (DEBUG_COMPACTION) { Slog.d(TAG_AM, "Skipping full compaction for process " + name + "; abs delta is too small: " + absDelta + "KB."); } return; } } } // Now we've passed through all the throttles and are going to compact, update // bookkeeping. switch (pendingAction) { case COMPACT_PROCESS_SOME: mSomeCompactionCount++; break; case COMPACT_PROCESS_FULL: mFullCompactionCount++; break; case COMPACT_PROCESS_PERSISTENT: mPersistentCompactionCount++; break; case COMPACT_PROCESS_BFGS: mBfgsCompactionCount++; break; default: break; } try { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "Compact " + ((pendingAction == COMPACT_PROCESS_SOME) ? "some" : "full") + ": " + name); long zramFreeKbBefore = Debug.getZramFreeKb(); mProcessDependencies.performCompaction(action, pid); long[] rssAfter = mProcessDependencies.getRss(pid); long end = SystemClock.uptimeMillis(); long time = end - start; long zramFreeKbAfter = Debug.getZramFreeKb(); EventLog.writeEvent(EventLogTags.AM_COMPACT, pid, name, action, rssBefore[0], rssBefore[1], rssBefore[2], rssBefore[3], rssAfter[0] - rssBefore[0], rssAfter[1] - rssBefore[1], rssAfter[2] - rssBefore[2], rssAfter[3] - rssBefore[3], time, lastCompactAction, lastCompactTime, lastOomAdj, procState, zramFreeKbBefore, zramFreeKbAfter - zramFreeKbBefore); // Note that as above not taking mPhenoTypeFlagLock here to avoid locking // on every single compaction for a flag that will seldom change and the // impact of reading the wrong value here is low. if (mRandom.nextFloat() < mCompactStatsdSampleRate) { FrameworkStatsLog.write(FrameworkStatsLog.APP_COMPACTED, pid, name, pendingAction, rssBefore[0], rssBefore[1], rssBefore[2], rssBefore[3], rssAfter[0], rssAfter[1], rssAfter[2], rssAfter[3], time, lastCompactAction, lastCompactTime, lastOomAdj, ActivityManager.processStateAmToProto(procState), zramFreeKbBefore, zramFreeKbAfter); } synchronized (mAm) { proc.lastCompactTime = end; proc.lastCompactAction = pendingAction; } if (action.equals(COMPACT_ACTION_FULL) || action.equals(COMPACT_ACTION_ANON)) { // Remove entry and insert again to update insertion order. mLastCompactionStats.remove(pid); mLastCompactionStats.put(pid, new LastCompactionStats(rssAfter)); } } catch (Exception e) { // nothing to do, presumably the process died } finally { Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); } break; } case COMPACT_SYSTEM_MSG: { Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "compactSystem"); compactSystem(); Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER); break; } } } } private final class FreezeHandler extends Handler { private FreezeHandler() { super(mCachedAppOptimizerThread.getLooper()); } @Override public void handleMessage(Message msg) { switch (msg.what) { case SET_FROZEN_PROCESS_MSG: freezeProcess((ProcessRecord) msg.obj); break; case REPORT_UNFREEZE_MSG: int pid = msg.arg1; int frozenDuration = msg.arg2; String processName = (String) msg.obj; reportUnfreeze(pid, frozenDuration, processName); break; default: return; } } private void freezeProcess(ProcessRecord proc) { final int pid; final String name; final long unfrozenDuration; final boolean frozen; synchronized (mAm) { pid = proc.pid; name = proc.processName; if (proc.curAdj < ProcessList.CACHED_APP_MIN_ADJ || proc.shouldNotFreeze) { if (DEBUG_FREEZER) { Slog.d(TAG_AM, "Skipping freeze for process " + pid + " " + name + " curAdj = " + proc.curAdj + ", shouldNotFreeze = " + proc.shouldNotFreeze); } return; } if (pid == 0 || proc.frozen) { // Already frozen or not a real process, either one being // launched or one being killed return; } long unfreezeTime = proc.freezeUnfreezeTime; try { Process.setProcessFrozen(pid, proc.uid, true); proc.freezeUnfreezeTime = SystemClock.uptimeMillis(); proc.frozen = true; } catch (Exception e) { Slog.w(TAG_AM, "Unable to freeze " + pid + " " + name); } unfrozenDuration = proc.freezeUnfreezeTime - unfreezeTime; frozen = proc.frozen; } if (frozen) { if (DEBUG_FREEZER) { Slog.d(TAG_AM, "froze " + pid + " " + name); } EventLog.writeEvent(EventLogTags.AM_FREEZE, pid, name); // See above for why we're not taking mPhenotypeFlagLock here if (mRandom.nextFloat() < mFreezerStatsdSampleRate) { FrameworkStatsLog.write(FrameworkStatsLog.APP_FREEZE_CHANGED, FrameworkStatsLog.APP_FREEZE_CHANGED__ACTION__FREEZE_APP, pid, name, unfrozenDuration); } } } private void reportUnfreeze(int pid, int frozenDuration, String processName) { EventLog.writeEvent(EventLogTags.AM_UNFREEZE, pid, processName); // See above for why we're not taking mPhenotypeFlagLock here if (mRandom.nextFloat() < mFreezerStatsdSampleRate) { FrameworkStatsLog.write( FrameworkStatsLog.APP_FREEZE_CHANGED, FrameworkStatsLog.APP_FREEZE_CHANGED__ACTION__UNFREEZE_APP, pid, processName, frozenDuration); } } } /** * Default implementation for ProcessDependencies, public vor visibility to OomAdjuster class. */ private static final class DefaultProcessDependencies implements ProcessDependencies { // Get memory RSS from process. @Override public long[] getRss(int pid) { return Process.getRss(pid); } // Compact process. @Override public void performCompaction(String action, int pid) throws IOException { try (FileOutputStream fos = new FileOutputStream("/proc/" + pid + "/reclaim")) { fos.write(action.getBytes()); } } } }