| /* |
| * 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.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.text.TextUtils; |
| import android.util.EventLog; |
| import android.util.Slog; |
| import android.util.StatsLog; |
| |
| import com.android.internal.annotations.GuardedBy; |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.server.ServiceThread; |
| |
| import java.io.FileOutputStream; |
| 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 AppCompactor { |
| |
| // Flags stored in the DeviceConfig API. |
| @VisibleForTesting static final String KEY_USE_COMPACTION = "use_compaction"; |
| @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_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 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; |
| |
| // 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; |
| |
| /** |
| * 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 mCompactionThread; |
| |
| private final ArrayList<ProcessRecord> mPendingCompactionProcesses = |
| new ArrayList<ProcessRecord>(); |
| 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)) { |
| updateStatsdSampleRate(); |
| } 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 final Random mRandom = new Random(); |
| @GuardedBy("mPhenotypeFlagLock") |
| @VisibleForTesting volatile float mStatsdSampleRate = DEFAULT_STATSD_SAMPLE_RATE; |
| @GuardedBy("mPhenotypeFlagLock") |
| @VisibleForTesting volatile long mFullAnonRssThrottleKb = |
| DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB; |
| @GuardedBy("mPhenoypeFlagLock") |
| @VisibleForTesting volatile long mFullDeltaRssThrottleKb = |
| DEFAULT_COMPACT_FULL_DELTA_RSS_THROTTLE_KB; |
| @GuardedBy("mPhenoypeFlagLock") |
| @VisibleForTesting final Set<Integer> mProcStateThrottle; |
| |
| // Handler on which compaction runs. |
| private Handler mCompactionHandler; |
| |
| // 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. |
| private Map<Integer, LastCompactionStats> mLastCompactionStats = |
| new LinkedHashMap<Integer, LastCompactionStats>() { |
| @Override |
| protected boolean removeEldestEntry(Map.Entry eldest) { |
| return size() > 100; |
| } |
| }; |
| |
| private int mSomeCompactionCount; |
| private int mFullCompactionCount; |
| private int mPersistentCompactionCount; |
| private int mBfgsCompactionCount; |
| |
| public AppCompactor(ActivityManagerService am) { |
| mAm = am; |
| mCompactionThread = new ServiceThread("CompactionThread", |
| THREAD_PRIORITY_FOREGROUND, true); |
| mProcStateThrottle = new HashSet<>(); |
| } |
| |
| @VisibleForTesting |
| AppCompactor(ActivityManagerService am, PropertyChangedCallbackForTest callback) { |
| this(am); |
| 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(); |
| updateStatsdSampleRate(); |
| updateFullRssThrottle(); |
| updateFullDeltaRssThrottle(); |
| updateProcStateThrottle(); |
| } |
| Process.setThreadGroupAndCpuset(mCompactionThread.getThreadId(), |
| Process.THREAD_GROUP_SYSTEM); |
| } |
| |
| /** |
| * Returns whether compaction is enabled. |
| */ |
| public boolean useCompaction() { |
| synchronized (mPhenotypeFlagLock) { |
| return mUseCompaction; |
| } |
| } |
| |
| @GuardedBy("mAm") |
| void dump(PrintWriter pw) { |
| pw.println("AppCompactor 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 + "=" + mStatsdSampleRate); |
| 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."); |
| if (DEBUG_COMPACTION) { |
| for (Map.Entry<Integer, LastCompactionStats> 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 compaction thread if needed. |
| */ |
| @GuardedBy("mPhenotypeFlagLock") |
| private void updateUseCompaction() { |
| mUseCompaction = DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, |
| KEY_USE_COMPACTION, DEFAULT_USE_COMPACTION); |
| if (mUseCompaction && !mCompactionThread.isAlive()) { |
| mCompactionThread.start(); |
| mCompactionHandler = new MemCompactionHandler(); |
| } |
| } |
| |
| @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 updateStatsdSampleRate() { |
| mStatsdSampleRate = DeviceConfig.getFloat(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, |
| KEY_COMPACT_STATSD_SAMPLE_RATE, DEFAULT_STATSD_SAMPLE_RATE); |
| mStatsdSampleRate = Math.min(1.0f, Math.max(0.0f, mStatsdSampleRate)); |
| } |
| |
| @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; |
| } |
| } |
| |
| private 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(mCompactionThread.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; |
| // remove rather than get so that insertion order will be updated when we |
| // put the post-compaction stats back into the map. |
| lastCompactionStats = mLastCompactionStats.remove(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 = Process.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(); |
| FileOutputStream fos = new FileOutputStream("/proc/" + pid + "/reclaim"); |
| fos.write(action.getBytes()); |
| fos.close(); |
| long[] rssAfter = Process.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() < mStatsdSampleRate) { |
| StatsLog.write(StatsLog.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)) { |
| 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; |
| } |
| } |
| } |
| } |
| } |
