From bdaf16e72aedf06f007c1a8b288c68ee470277d1 Mon Sep 17 00:00:00 2001 From: Marco Ballesio Date: Thu, 23 Jan 2020 13:57:00 -0800 Subject: [PATCH] Add support for freezing cached apps MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Freeze apps when cached and unfreeze them once removed from the cache or killed. Frozen apps will not use any CPU cycles, reducing power consumption for misbehaving processes which might attempt to run while cached. Change-Id: Ib055352062825db62927015c33ee0a285aa4630c Depends-On: pa/1495867, ag/9976279, ag/9981529, ag/9987868¬ Bug: 143308662 Test: manual, atest CachedAppOptimizerTest --- core/java/android/os/Process.java | 11 + core/jni/android_util_Process.cpp | 17 ++ .../server/am/ActivityManagerDebugConfig.java | 1 + .../android/server/am/CachedAppOptimizer.java | 251 +++++++++++++++++- .../android/server/am/EventLogTags.logtags | 5 + .../com/android/server/am/OomAdjuster.java | 17 ++ .../com/android/server/am/ProcessRecord.java | 4 +- .../server/am/CachedAppOptimizerTest.java | 18 +- 8 files changed, 303 insertions(+), 21 deletions(-) diff --git a/core/java/android/os/Process.java b/core/java/android/os/Process.java index c7a8474c8038d..0f11d48b595ae 100644 --- a/core/java/android/os/Process.java +++ b/core/java/android/os/Process.java @@ -855,6 +855,17 @@ public class Process { public static final native void setProcessGroup(int pid, int group) throws IllegalArgumentException, SecurityException; + /** + * Freeze or unfreeze the specified process. + * + * @param pid Identifier of the process to freeze or unfreeze. + * @param uid Identifier of the user the process is running under. + * @param frozen Specify whether to free (true) or unfreeze (false). + * + * @hide + */ + public static final native void setProcessFrozen(int pid, int uid, boolean frozen); + /** * Return the scheduling group of requested process. * diff --git a/core/jni/android_util_Process.cpp b/core/jni/android_util_Process.cpp index 89dbca816d61b..0eb364d40920a 100644 --- a/core/jni/android_util_Process.cpp +++ b/core/jni/android_util_Process.cpp @@ -330,6 +330,22 @@ void android_os_Process_setProcessGroup(JNIEnv* env, jobject clazz, int pid, jin closedir(d); } +void android_os_Process_setProcessFrozen( + JNIEnv *env, jobject clazz, jint pid, jint uid, jboolean freeze) +{ + bool success = true; + + if (freeze) { + success = SetProcessProfiles(uid, pid, {"Frozen"}); + } else { + success = SetProcessProfiles(uid, pid, {"Unfrozen"}); + } + + if (!success) { + signalExceptionForGroupError(env, EINVAL, pid); + } +} + jint android_os_Process_getProcessGroup(JNIEnv* env, jobject clazz, jint pid) { SchedPolicy sp; @@ -1327,6 +1343,7 @@ static const JNINativeMethod methods[] = { {"setGid", "(I)I", (void*)android_os_Process_setGid}, {"sendSignal", "(II)V", (void*)android_os_Process_sendSignal}, {"sendSignalQuiet", "(II)V", (void*)android_os_Process_sendSignalQuiet}, + {"setProcessFrozen", "(IIZ)V", (void*)android_os_Process_setProcessFrozen}, {"getFreeMemory", "()J", (void*)android_os_Process_getFreeMemory}, {"getTotalMemory", "()J", (void*)android_os_Process_getTotalMemory}, {"readProcLines", "(Ljava/lang/String;[Ljava/lang/String;[J)V", diff --git a/services/core/java/com/android/server/am/ActivityManagerDebugConfig.java b/services/core/java/com/android/server/am/ActivityManagerDebugConfig.java index ed64475084b8d..b19a37e0d840a 100644 --- a/services/core/java/com/android/server/am/ActivityManagerDebugConfig.java +++ b/services/core/java/com/android/server/am/ActivityManagerDebugConfig.java @@ -50,6 +50,7 @@ class ActivityManagerDebugConfig { static final boolean DEBUG_BROADCAST_LIGHT = DEBUG_BROADCAST || false; static final boolean DEBUG_BROADCAST_DEFERRAL = DEBUG_BROADCAST || false; static final boolean DEBUG_COMPACTION = DEBUG_ALL || false; + static final boolean DEBUG_FREEZER = DEBUG_ALL || false; static final boolean DEBUG_LRU = DEBUG_ALL || false; static final boolean DEBUG_MU = DEBUG_ALL || false; static final boolean DEBUG_NETWORK = DEBUG_ALL || false; diff --git a/services/core/java/com/android/server/am/CachedAppOptimizer.java b/services/core/java/com/android/server/am/CachedAppOptimizer.java index 3ca5ebce93f2b..6819578d9cdce 100644 --- a/services/core/java/com/android/server/am/CachedAppOptimizer.java +++ b/services/core/java/com/android/server/am/CachedAppOptimizer.java @@ -19,6 +19,7 @@ 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; @@ -42,6 +43,7 @@ import com.android.internal.annotations.VisibleForTesting; import com.android.server.ServiceThread; import java.io.FileOutputStream; +import java.io.FileReader; import java.io.PrintWriter; import java.util.ArrayList; import java.util.Arrays; @@ -55,6 +57,7 @@ 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"; @@ -65,6 +68,8 @@ public final class CachedAppOptimizer { @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 = @@ -85,6 +90,7 @@ public final class CachedAppOptimizer { // 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; @@ -114,6 +120,13 @@ public final class CachedAppOptimizer { 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; + + //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 DO_UNFREEZE = 2; /** * This thread must be moved to the system background cpuset. @@ -144,7 +157,9 @@ public final class CachedAppOptimizer { || KEY_COMPACT_THROTTLE_4.equals(name)) { updateCompactionThrottles(); } else if (KEY_COMPACT_STATSD_SAMPLE_RATE.equals(name)) { - updateStatsdSampleRate(); + 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)) { @@ -183,9 +198,11 @@ public final class CachedAppOptimizer { @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 mStatsdSampleRate = DEFAULT_STATSD_SAMPLE_RATE; + @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; @@ -197,6 +214,7 @@ public final class CachedAppOptimizer { // Handler on which compaction runs. private 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 @@ -238,10 +256,12 @@ public final class CachedAppOptimizer { updateUseCompaction(); updateCompactionActions(); updateCompactionThrottles(); - updateStatsdSampleRate(); + updateCompactStatsdSampleRate(); + updateFreezerStatsdSampleRate(); updateFullRssThrottle(); updateFullDeltaRssThrottle(); updateProcStateThrottle(); + updateUseFreezer(); } Process.setThreadGroupAndCpuset(mCachedAppOptimizerThread.getThreadId(), Process.THREAD_GROUP_SYSTEM); @@ -256,6 +276,15 @@ public final class CachedAppOptimizer { } } + /** + * Returns whether freezer is enabled. + */ + public boolean useFreezer() { + synchronized (mPhenotypeFlagLock) { + return mUseFreezer; + } + } + @GuardedBy("mAm") void dump(PrintWriter pw) { pw.println("CachedAppOptimizer settings"); @@ -269,7 +298,7 @@ public final class CachedAppOptimizer { 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_STATSD_SAMPLE_RATE + "=" + mCompactStatsdSampleRate); pw.println(" " + KEY_COMPACT_FULL_RSS_THROTTLE_KB + "=" + mFullAnonRssThrottleKb); pw.println(" " + KEY_COMPACT_FULL_DELTA_RSS_THROTTLE_KB + "=" @@ -283,6 +312,8 @@ public final class CachedAppOptimizer { 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()) { @@ -356,18 +387,76 @@ public final class CachedAppOptimizer { /** * Reads the flag value from DeviceConfig to determine whether app compaction - * should be enabled, and starts the compaction thread if needed. + * 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 && !mCachedAppOptimizerThread.isAlive()) { - mCachedAppOptimizerThread.start(); + + if (mUseCompaction) { + if (!mCachedAppOptimizerThread.isAlive()) { + mCachedAppOptimizerThread.start(); + } + mCompactionHandler = new MemCompactionHandler(); } } + /** + * Determines whether the freezer is correctly supported by this system + */ + public 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() { + if (DeviceConfig.getBoolean(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, + 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, @@ -433,10 +522,17 @@ public final class CachedAppOptimizer { } @GuardedBy("mPhenotypeFlagLock") - private void updateStatsdSampleRate() { - mStatsdSampleRate = DeviceConfig.getFloat(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, + private void updateCompactStatsdSampleRate() { + mCompactStatsdSampleRate = 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)); + 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") @@ -507,6 +603,24 @@ public final class CachedAppOptimizer { } } + @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 unfreezeAppAsync(ProcessRecord app) { + mFreezeHandler.removeMessages(SET_FROZEN_PROCESS_MSG, app); + + mFreezeHandler.sendMessage( + mFreezeHandler.obtainMessage(SET_FROZEN_PROCESS_MSG, DO_UNFREEZE, 0, app)); + } + private static final class LastCompactionStats { private final long[] mRssAfterCompaction; @@ -734,7 +848,7 @@ public final class CachedAppOptimizer { // 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) { + if (mRandom.nextFloat() < mCompactStatsdSampleRate) { 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, @@ -768,4 +882,119 @@ public final class CachedAppOptimizer { } } } + + private final class FreezeHandler extends Handler { + private FreezeHandler() { + super(mCachedAppOptimizerThread.getLooper()); + } + + @Override + public void handleMessage(Message msg) { + if (msg.what != SET_FROZEN_PROCESS_MSG) { + return; + } + + if (msg.arg1 == DO_FREEZE) { + freezeProcess((ProcessRecord) msg.obj); + } else if (msg.arg1 == DO_UNFREEZE) { + unfreezeProcess((ProcessRecord) msg.obj); + } + } + + 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) { + if (DEBUG_FREEZER) { + Slog.d(TAG_AM, "Skipping freeze for process " + pid + + " " + name + " (not cached)"); + } + 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); + } + } + + private void unfreezeProcess(ProcessRecord proc) { + final int pid; + final String name; + final long frozenDuration; + final boolean frozen; + + synchronized (mAm) { + pid = proc.pid; + name = proc.processName; + + if (!proc.frozen) { + if (DEBUG_FREEZER) { + Slog.d(TAG_AM, + "Skipping unfreeze for process " + pid + " " + + name + " (not frozen)"); + } + return; + } + + if (pid == 0) { + // Not a real process, either being launched or killed + return; + } + + long freezeTime = proc.freezeUnfreezeTime; + + try { + Process.setProcessFrozen(proc.pid, proc.uid, false); + + proc.freezeUnfreezeTime = SystemClock.uptimeMillis(); + proc.frozen = false; + } catch (Exception e) { + Slog.w(TAG_AM, "Unable to unfreeze " + pid + " " + name); + } + + frozenDuration = proc.freezeUnfreezeTime - freezeTime; + frozen = proc.frozen; + } + + if (!frozen) { + if (DEBUG_FREEZER) { + Slog.d(TAG_AM, "unfroze " + pid + " " + name); + } + + EventLog.writeEvent(EventLogTags.AM_UNFREEZE, pid, name); + } + } + } } diff --git a/services/core/java/com/android/server/am/EventLogTags.logtags b/services/core/java/com/android/server/am/EventLogTags.logtags index 23674bbd89c73..cc5df4017f28c 100644 --- a/services/core/java/com/android/server/am/EventLogTags.logtags +++ b/services/core/java/com/android/server/am/EventLogTags.logtags @@ -88,3 +88,8 @@ option java_package com.android.server.am # The task is being compacted 30063 am_compact (Pid|1|5),(Process Name|3),(Action|3),(BeforeRssTotal|2|2),(BeforeRssFile|2|2),(BeforeRssAnon|2|2),(BeforeRssSwap|2|2),(DeltaRssTotal|2|2),(DeltaRssFile|2|2),(DeltaRssAnon|2|2),(DeltaRssSwap|2|2),(Time|2|3),(LastAction|1|2),(LastActionTimestamp|2|3),(setAdj|1|2),(procState|1|2),(BeforeZRAMFree|2|2),(DeltaZRAMFree|2|2) +# The task is being frozen +30068 am_freeze (Pid|1|5),(Process Name|3) + +# The task is being unfrozen +30069 am_unfreeze (Pid|1|5),(Process Name|3) diff --git a/services/core/java/com/android/server/am/OomAdjuster.java b/services/core/java/com/android/server/am/OomAdjuster.java index 04297828ebfce..c831ac490d71d 100644 --- a/services/core/java/com/android/server/am/OomAdjuster.java +++ b/services/core/java/com/android/server/am/OomAdjuster.java @@ -2173,6 +2173,9 @@ public final class OomAdjuster { app.repForegroundActivities = app.hasForegroundActivities(); changes |= ActivityManagerService.ProcessChangeItem.CHANGE_ACTIVITIES; } + + updateAppFreezeStateLocked(app); + if (app.getReportedProcState() != app.getCurProcState()) { app.setReportedProcState(app.getCurProcState()); if (app.thread != null) { @@ -2489,4 +2492,18 @@ public final class OomAdjuster { void dumpCachedAppOptimizerSettings(PrintWriter pw) { mCachedAppOptimizer.dump(pw); } + + @GuardedBy("mService") + void updateAppFreezeStateLocked(ProcessRecord app) { + if (!mCachedAppOptimizer.useFreezer()) { + return; + } + + // Use current adjustment when freezing, set adjustment when unfreezing. + if (app.curAdj >= ProcessList.CACHED_APP_MIN_ADJ && !app.frozen) { + mCachedAppOptimizer.freezeAppAsync(app); + } else if (app.setAdj < ProcessList.CACHED_APP_MIN_ADJ && app.frozen) { + mCachedAppOptimizer.unfreezeAppAsync(app); + } + } } diff --git a/services/core/java/com/android/server/am/ProcessRecord.java b/services/core/java/com/android/server/am/ProcessRecord.java index 0e1e0f9f64f17..1e2dd2deb568a 100644 --- a/services/core/java/com/android/server/am/ProcessRecord.java +++ b/services/core/java/com/android/server/am/ProcessRecord.java @@ -163,6 +163,8 @@ class ProcessRecord implements WindowProcessListener { long lastCompactTime; // The last time that this process was compacted int reqCompactAction; // The most recent compaction action requested for this app. int lastCompactAction; // The most recent compaction action performed for this app. + boolean frozen; // True when the process is frozen. + long freezeUnfreezeTime; // Last time the app was (un)frozen, 0 for never private int mCurSchedGroup; // Currently desired scheduling class int setSchedGroup; // Last set to background scheduling class int trimMemoryLevel; // Last selected memory trimming level @@ -623,7 +625,7 @@ class ProcessRecord implements WindowProcessListener { curAdj = setAdj = verifiedAdj = ProcessList.INVALID_ADJ; mPersistent = false; removed = false; - lastStateTime = lastPssTime = nextPssTime = SystemClock.uptimeMillis(); + freezeUnfreezeTime = lastStateTime = lastPssTime = nextPssTime = SystemClock.uptimeMillis(); mWindowProcessController = new WindowProcessController( mService.mActivityTaskManager, info, processName, uid, userId, this, this); pkgList.put(_info.packageName, new ProcessStats.ProcessStateHolder(_info.longVersionCode)); diff --git a/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java b/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java index f037692886ab6..1985513c42904 100644 --- a/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/am/CachedAppOptimizerTest.java @@ -120,7 +120,7 @@ public final class CachedAppOptimizerTest { CachedAppOptimizer.DEFAULT_COMPACT_THROTTLE_3); assertThat(mCachedAppOptimizerUnderTest.mCompactThrottleFullFull).isEqualTo( CachedAppOptimizer.DEFAULT_COMPACT_THROTTLE_4); - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo( + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo( CachedAppOptimizer.DEFAULT_STATSD_SAMPLE_RATE); assertThat(mCachedAppOptimizerUnderTest.mFullAnonRssThrottleKb).isEqualTo( CachedAppOptimizer.DEFAULT_COMPACT_FULL_RSS_THROTTLE_KB); @@ -209,7 +209,7 @@ public final class CachedAppOptimizerTest { CachedAppOptimizer.DEFAULT_COMPACT_THROTTLE_5 + 1); assertThat(mCachedAppOptimizerUnderTest.mCompactThrottlePersistent).isEqualTo( CachedAppOptimizer.DEFAULT_COMPACT_THROTTLE_6 + 1); - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo( + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo( CachedAppOptimizer.DEFAULT_STATSD_SAMPLE_RATE + 0.1f); assertThat(mCachedAppOptimizerUnderTest.mCompactThrottleBFGS).isEqualTo( CachedAppOptimizer.DEFAULT_COMPACT_THROTTLE_5 + 1); @@ -472,7 +472,7 @@ public final class CachedAppOptimizerTest { public void statsdSampleRate_listensToDeviceConfigChanges() throws InterruptedException { mCachedAppOptimizerUnderTest.init(); - // When we override mStatsdSampleRate with a reasonable value ... + // When we override mCompactStatsdSampleRate with a reasonable value ... mCountDown = new CountDownLatch(1); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, CachedAppOptimizer.KEY_COMPACT_STATSD_SAMPLE_RATE, @@ -480,7 +480,7 @@ public final class CachedAppOptimizerTest { assertThat(mCountDown.await(5, TimeUnit.SECONDS)).isTrue(); // Then that override is reflected in the compactor. - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo( + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo( CachedAppOptimizer.DEFAULT_STATSD_SAMPLE_RATE + 0.1f); } @@ -489,14 +489,14 @@ public final class CachedAppOptimizerTest { throws InterruptedException { mCachedAppOptimizerUnderTest.init(); - // When we override mStatsdSampleRate with an unreasonable value ... + // When we override mCompactStatsdSampleRate with an unreasonable value ... mCountDown = new CountDownLatch(1); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, CachedAppOptimizer.KEY_COMPACT_STATSD_SAMPLE_RATE, "foo", false); assertThat(mCountDown.await(5, TimeUnit.SECONDS)).isTrue(); // Then that override is reflected in the compactor. - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo( + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo( CachedAppOptimizer.DEFAULT_STATSD_SAMPLE_RATE); } @@ -505,7 +505,7 @@ public final class CachedAppOptimizerTest { throws InterruptedException { mCachedAppOptimizerUnderTest.init(); - // When we override mStatsdSampleRate with an value outside of [0..1]... + // When we override mCompactStatsdSampleRate with an value outside of [0..1]... mCountDown = new CountDownLatch(1); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, CachedAppOptimizer.KEY_COMPACT_STATSD_SAMPLE_RATE, @@ -513,7 +513,7 @@ public final class CachedAppOptimizerTest { assertThat(mCountDown.await(5, TimeUnit.SECONDS)).isTrue(); // Then the values is capped in the range. - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo(0.0f); + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo(0.0f); mCountDown = new CountDownLatch(1); DeviceConfig.setProperty(DeviceConfig.NAMESPACE_ACTIVITY_MANAGER, @@ -522,7 +522,7 @@ public final class CachedAppOptimizerTest { assertThat(mCountDown.await(5, TimeUnit.SECONDS)).isTrue(); // Then the values is capped in the range. - assertThat(mCachedAppOptimizerUnderTest.mStatsdSampleRate).isEqualTo(1.0f); + assertThat(mCachedAppOptimizerUnderTest.mCompactStatsdSampleRate).isEqualTo(1.0f); } @Test