Merge "Wrap updateLruProcessLocked in a PSC method" into main (132249d4) · Commits · e / os / android_frameworks_base

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

+3 −2

Original line number	Diff line number	Diff line
		@@ -2491,6 +2491,7 @@ public class ActivityManagerService extends IActivityManager.Stub
		mProcessStateController = new ProcessStateController.Builder(this, mProcessList, activeUids)
		.setLockObject(this)
		.setTopProcessChangeCallback(this::updateTopAppListeners)
		.setProcessLruUpdater(mProcessList)
		.build();
		mOomAdjuster = mProcessStateController.getOomAdjuster();

		@@ -2892,12 +2893,12 @@ public class ActivityManagerService extends IActivityManager.Stub
		@GuardedBy("this")
		final void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
		ProcessRecord client) {
		mProcessList.updateLruProcessLocked(app, activityChange, client);
		mProcessStateController.updateLruProcess(app, activityChange, client);
		}

		@GuardedBy("this")
		final void removeLruProcessLocked(ProcessRecord app) {
		mProcessList.removeLruProcessLocked(app);
		mProcessStateController.removeLruProcess(app);
		}

		@GuardedBy("this")

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

+1 −1

Original line number	Diff line number	Diff line
		@@ -1484,7 +1484,7 @@ public class ContentProviderHelper {
		// the "getContentProviderImpl" tag here, because it's part
		// of the checktime log in getContentProviderImpl().
		checkTime(startTime, "getContentProviderImpl: before updateLruProcess");
		processList.updateLruProcessLocked(cpr.proc, false, null);
		mService.mProcessStateController.updateLruProcess(cpr.proc, false, null);
		checkTime(startTime, "getContentProviderImpl: after updateLruProcess");
		}
		return conn;

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

+8 −5

Original line number	Diff line number	Diff line
		@@ -181,7 +181,7 @@ import java.util.function.Function;
		/**
		* Activity manager code dealing with processes.
		*/
		public final class ProcessList {
		public final class ProcessList implements ProcessStateController.ProcessLruUpdater {
		static final String TAG = TAG_WITH_CLASS_NAME ? "ProcessList" : TAG_AM;

		static final String TAG_PROCESS_OBSERVERS = TAG + POSTFIX_PROCESS_OBSERVERS;
		@@ -2948,7 +2948,8 @@ public final class ProcessList {
		}

		@GuardedBy("mService")
		void removeLruProcessLocked(ProcessRecord app) {
		@Override
		public void removeLruProcessLocked(ProcessRecord app) {
		int lrui = mLruProcesses.lastIndexOf(app);
		if (lrui >= 0) {
		synchronized (mProcLock) {
		@@ -3257,7 +3258,7 @@ public final class ProcessList {
		mService.handleAppDiedLocked(app, pid, willRestart, allowRestart,
		false /* fromBinderDied */);
		if (willRestart) {
		removeLruProcessLocked(app);
		mService.mProcessStateController.removeLruProcess(app);
		mService.addAppLocked(app.info, null, false, null /* ABI override */,
		ZYGOTE_POLICY_FLAG_EMPTY);
		}
		@@ -3930,7 +3931,9 @@ public final class ProcessList {
		}

		@GuardedBy("mService")
		void updateLruProcessLocked(ProcessRecord app, boolean activityChange, ProcessRecord client) {
		@Override
		public void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
		ProcessRecord client) {
		final ProcessServiceRecord psr = app.mServices;
		final boolean hasActivity = app.hasActivitiesOrRecentTasks() \|\| psr.hasClientActivities()
		\|\| psr.isTreatedLikeActivity();
		@@ -5544,7 +5547,7 @@ public final class ProcessList {
		app.setDyingPid(0);
		handlePrecedingAppDiedLocked(app);
		// Remove from the LRU list if it's still there.
		removeLruProcessLocked(app);
		mService.mProcessStateController.removeLruProcess(app);
		return true;
		}
		return false;

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

+54 −2

Original line number	Diff line number	Diff line
		@@ -65,6 +65,8 @@ public class ProcessStateController {

		private final Consumer<ProcessRecord> mTopChangeCallback;

		private final ProcessLruUpdater mProcessLruUpdater;

		private final GlobalState mGlobalState = new GlobalState();

		/**
		@@ -75,13 +77,15 @@ public class ProcessStateController {
		private ProcessStateController(ActivityManagerService ams, ProcessList processList,
		ActiveUids activeUids, ServiceThread handlerThread,
		CachedAppOptimizer cachedAppOptimizer, Object lock, Object procLock,
		Consumer<ProcessRecord> topChangeCallback, OomAdjuster.Injector oomAdjInjector) {
		Consumer<ProcessRecord> topChangeCallback, ProcessLruUpdater lruUpdater,
		OomAdjuster.Injector oomAdjInjector) {
		mOomAdjuster = new OomAdjusterImpl(ams, processList, activeUids, handlerThread,
		mGlobalState, cachedAppOptimizer, oomAdjInjector);

		mLock = lock;
		mProcLock = procLock;
		mTopChangeCallback = topChangeCallback;
		mProcessLruUpdater = lruUpdater;
		final Handler serviceHandler = new Handler(handlerThread.getLooper());
		mServiceBinderCallUpdater = (cr, hasOngoingCalls) -> serviceHandler.post(() -> {
		synchronized (ams) {
		@@ -385,6 +389,23 @@ public class ProcessStateController {
		}
		}

		/**
		* Bump a process to the end of the LRU list.
		*/
		@GuardedBy("mLock")
		public void updateLruProcess(@NonNull ProcessRecord proc, boolean activityChange,
		@Nullable ProcessRecord client) {
		mProcessLruUpdater.updateLruProcessLocked(proc, activityChange, client);
		}

		/**
		* Remove a process from the LRU list.
		*/
		@GuardedBy("mLock")
		public void removeLruProcess(@NonNull ProcessRecord proc) {
		mProcessLruUpdater.removeLruProcessLocked(proc);
		}

		/******************* Process Visibility State Events *******************/
		/**
		* Note whether a process has Top UI or not.
		@@ -1110,6 +1131,19 @@ public class ProcessStateController {
		}
		}

		/**
		* Interface for injecting LRU management into ProcessStateController
		* TODO(b/430385382): This should be remove when LRU is managed entirely within
		* ProcessStateController.
		*/
		public interface ProcessLruUpdater {
		/** Bump a process to the end of the LRU list */
		void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
		ProcessRecord client);
		/** Remove a process from the LRU list */
		void removeLruProcessLocked(ProcessRecord app);
		}

		/**
		* Builder for ProcessStateController.
		*/
		@@ -1122,6 +1156,7 @@ public class ProcessStateController {
		private CachedAppOptimizer mCachedAppOptimizer = null;
		private Object mLock = null;
		private Consumer<ProcessRecord> mTopChangeCallback = null;
		private ProcessLruUpdater mProcessLruUpdater = null;
		private OomAdjuster.Injector mOomAdjInjector = null;

		public Builder(ActivityManagerService ams, ProcessList processList, ActiveUids activeUids) {
		@@ -1146,12 +1181,20 @@ public class ProcessStateController {
		if (mTopChangeCallback == null) {
		mTopChangeCallback = proc -> {};
		}
		if (mProcessLruUpdater == null) {
		// Just attach a no-op updater. For Testing that does not care about the LRU.
		mProcessLruUpdater = new ProcessLruUpdater() {
		public void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
		ProcessRecord client) {}
		public void removeLruProcessLocked(ProcessRecord app) {}
		};
		}
		if (mOomAdjInjector == null) {
		mOomAdjInjector = new OomAdjuster.Injector();
		}
		return new ProcessStateController(mAms, mProcessList, mActiveUids, mHandlerThread,
		mCachedAppOptimizer, mLock, mAms.mProcLock, mTopChangeCallback,
		mOomAdjInjector);
		mProcessLruUpdater, mOomAdjInjector);
		}

		/**
		@@ -1197,5 +1240,14 @@ public class ProcessStateController {
		mTopChangeCallback = callback;
		return this;
		}

		/**
		* Set a callback for when ProcessStateController is informed about the Top process
		* changing.
		*/
		public Builder setProcessLruUpdater(ProcessLruUpdater updater) {
		mProcessLruUpdater = updater;
		return this;
		}
		}
		}

services/tests/mockingservicestests/src/com/android/server/am/MockingOomAdjusterTests.java

+26 −11

Original line number	Diff line number	Diff line
		@@ -135,6 +135,7 @@ import android.util.SparseBooleanArray;
		import android.util.SparseIntArray;

		import com.android.server.LocalServices;
		import com.android.server.am.ProcessStateController.ProcessLruUpdater;
		import com.android.server.am.psc.ProcessRecordInternal;
		import com.android.server.tests.assertutils.FlagAssert;
		import com.android.server.wm.ActivityServiceConnectionsHolder;
		@@ -153,7 +154,6 @@ import java.lang.reflect.Field;
		import java.lang.reflect.Modifier;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collections;
		import java.util.List;
		import java.util.concurrent.CountDownLatch;
		import java.util.concurrent.TimeUnit;
		@@ -284,9 +284,25 @@ public class MockingOomAdjusterTests {
		mActivityStateHandlerThread = new HandlerThread("ActivityStateThread");
		mActivityStateHandlerThread.start();
		mActivityStateHandler = new Handler(mActivityStateHandlerThread.getLooper());
		ProcessLruUpdater lruUpdater = new ProcessLruUpdater() {
		@Override
		public void updateLruProcessLocked(ProcessRecord app, boolean activityChange,
		ProcessRecord client) {
		ArrayList<ProcessRecord> lru = mService.mProcessList.getLruProcessesLOSP();
		lru.remove(app);
		lru.add(app);
		}

		@Override
		public void removeLruProcessLocked(ProcessRecord app) {
		ArrayList<ProcessRecord> lru = mService.mProcessList.getLruProcessesLOSP();
		lru.remove(app);
		}
		};
		mProcessStateController = new ProcessStateController.Builder(mService,
		mService.mProcessList, mActiveUids)
		.setCachedAppOptimizer(mTestCachedAppOptimizer)
		.setProcessLruUpdater(lruUpdater)
		.setOomAdjusterInjector(mInjector)
		.build();
		mActivityStateAsyncUpdater = mProcessStateController.createActivityStateAsyncUpdater(
		@@ -399,14 +415,15 @@ public class MockingOomAdjusterTests {
		}
		}

		/**
		* Replace the process LRU with the given processes.
		*/
		@SuppressWarnings("GuardedBy")
		private void setProcessesToLru(ProcessRecord... apps) {
		ArrayList<ProcessRecord> lru = mService.mProcessList.getLruProcessesLOSP();
		lru.clear();
		Collections.addAll(lru, apps);
		for (ProcessRecord app : apps) {
		updateProcessLru(app);
		}
		}

		private void updateProcessLru(ProcessRecord app) {
		mProcessStateController.updateLruProcess(app, false, null);
		}

		/**
		@@ -424,10 +441,8 @@ public class MockingOomAdjusterTests {
		updateProcessRecordNodes(Arrays.asList(apps));
		if (apps.length == 1) {
		final ProcessRecord app = apps[0];
		if (!mService.mProcessList.getLruProcessesLOSP().contains(app)) {
		mService.mProcessList.getLruProcessesLOSP().add(app);
		}
		mProcessStateController.runUpdate(apps[0], OOM_ADJ_REASON_NONE);
		updateProcessLru(app);
		mProcessStateController.runUpdate(app, OOM_ADJ_REASON_NONE);
		} else {
		setProcessesToLru(apps);
		mProcessStateController.runFullUpdate(OOM_ADJ_REASON_NONE);