Merge "Add annotation to the performance sensitive methods" (91240cec) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/wm/ActivityStarter.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -938,7 +938,7 @@ class ActivityStarter {
		return false;
		}
		// don't abort if the callingUid is in the foreground or is a persistent system process
		final int callingUidProcState = mService.getUidStateLocked(callingUid);
		final int callingUidProcState = mService.getUidState(callingUid);
		final boolean callingUidHasAnyVisibleWindow =
		mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(callingUid);
		final boolean isCallingUidForeground = callingUidHasAnyVisibleWindow
		@@ -951,7 +951,7 @@ class ActivityStarter {
		// take realCallingUid into consideration
		final int realCallingUidProcState = (callingUid == realCallingUid)
		? callingUidProcState
		: mService.getUidStateLocked(realCallingUid);
		: mService.getUidState(realCallingUid);
		final boolean realCallingUidHasAnyVisibleWindow = (callingUid == realCallingUid)
		? callingUidHasAnyVisibleWindow
		: mService.mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(realCallingUid);

services/core/java/com/android/server/wm/ActivityTaskManagerService.java

+51 −30

Original line number	Diff line number	Diff line
		@@ -26,7 +26,6 @@ import static android.Manifest.permission.REMOVE_TASKS;
		import static android.Manifest.permission.START_TASKS_FROM_RECENTS;
		import static android.Manifest.permission.STOP_APP_SWITCHES;
		import static android.app.ActivityManager.LOCK_TASK_MODE_NONE;
		import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;
		import static android.app.ActivityManagerInternal.ALLOW_FULL_ONLY;
		import static android.app.ActivityTaskManager.INVALID_TASK_ID;
		import static android.app.ActivityTaskManager.RESIZE_MODE_PRESERVE_WINDOW;
		@@ -272,6 +271,10 @@ import java.io.FileReader;
		import java.io.IOException;
		import java.io.PrintWriter;
		import java.io.StringWriter;
		import java.lang.annotation.ElementType;
		import java.lang.annotation.Retention;
		import java.lang.annotation.RetentionPolicy;
		import java.lang.annotation.Target;
		import java.lang.ref.WeakReference;
		import java.text.DateFormat;
		import java.util.ArrayList;
		@@ -363,7 +366,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		private UserManagerService mUserManager;
		private AppOpsService mAppOpsService;
		/** All active uids in the system. */
		private final SparseArray<Integer> mActiveUids = new SparseArray<>();
		private final MirrorActiveUids mActiveUids = new MirrorActiveUids();
		private final SparseArray<String> mPendingTempWhitelist = new SparseArray<>();
		/** All processes currently running that might have a window organized by name. */
		final ProcessMap<WindowProcessController> mProcessNames = new ProcessMap<>();
		@@ -647,6 +650,17 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		/** Indicates that the method may be invoked frequently or is sensitive to performance. */
		@Target(ElementType.METHOD)
		@Retention(RetentionPolicy.SOURCE)
		@interface HotPath {
		int NONE = 0;
		int OOM_ADJUSTMENT = 1;
		int LRU_UPDATE = 2;
		int PROCESS_CHANGE = 3;
		int caller() default NONE;
		}

		@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
		public ActivityTaskManagerService(Context context) {
		mContext = context;
		@@ -5720,12 +5734,12 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		return null;
		}

		int getUidStateLocked(int uid) {
		return mActiveUids.get(uid, PROCESS_STATE_NONEXISTENT);
		int getUidState(int uid) {
		return mActiveUids.getUidState(uid);
		}

		boolean isUidForeground(int uid) {
		return (getUidStateLocked(uid) == ActivityManager.PROCESS_STATE_TOP)
		return (getUidState(uid) == ActivityManager.PROCESS_STATE_TOP)
		\|\| mWindowManager.mRoot.isAnyNonToastWindowVisibleForUid(uid);
		}

		@@ -6118,23 +6132,26 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void onProcessAdded(WindowProcessController proc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		mProcessNames.put(proc.mName, proc.mUid, proc);
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void onProcessRemoved(String name, int uid) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		mProcessNames.remove(name, uid);
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void onCleanUpApplicationRecord(WindowProcessController proc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		if (proc == mHomeProcess) {
		mHomeProcess = null;
		}
		@@ -6144,23 +6161,26 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public int getTopProcessState() {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		return mTopProcessState;
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public boolean isHeavyWeightProcess(WindowProcessController proc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		return proc == mHeavyWeightProcess;
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void clearHeavyWeightProcessIfEquals(WindowProcessController proc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		ActivityTaskManagerService.this.clearHeavyWeightProcessIfEquals(proc);
		}
		}
		@@ -6176,9 +6196,10 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public boolean isSleeping() {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		return isSleepingLocked();
		}
		}
		@@ -6422,9 +6443,10 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public boolean isFactoryTestProcess(WindowProcessController wpc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		if (mFactoryTest == FACTORY_TEST_OFF) {
		return false;
		}
		@@ -6477,10 +6499,11 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void handleAppDied(WindowProcessController wpc, boolean restarting,
		Runnable finishInstrumentationCallback) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		// Remove this application's activities from active lists.
		boolean hasVisibleActivities = mRootActivityContainer.handleAppDied(wpc);

		@@ -6579,16 +6602,18 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public void preBindApplication(WindowProcessController wpc) {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		mStackSupervisor.getActivityMetricsLogger().notifyBindApplication(wpc.mInfo);
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		@Override
		public boolean attachApplication(WindowProcessController wpc) throws RemoteException {
		synchronized (mGlobalLock) {
		synchronized (mGlobalLockWithoutBoost) {
		return mRootActivityContainer.attachApplication(wpc);
		}
		}
		@@ -6916,6 +6941,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public WindowProcessController getTopApp() {
		synchronized (mGlobalLockWithoutBoost) {
		@@ -6924,6 +6950,7 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public void rankTaskLayersIfNeeded() {
		synchronized (mGlobalLockWithoutBoost) {
		@@ -6968,34 +6995,28 @@ public class ActivityTaskManagerService extends IActivityTaskManager.Stub {
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public void onUidActive(int uid, int procState) {
		synchronized (mGlobalLockWithoutBoost) {
		mActiveUids.put(uid, procState);
		}
		mActiveUids.onUidActive(uid, procState);
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public void onUidInactive(int uid) {
		synchronized (mGlobalLockWithoutBoost) {
		mActiveUids.remove(uid);
		}
		mActiveUids.onUidInactive(uid);
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public void onActiveUidsCleared() {
		synchronized (mGlobalLockWithoutBoost) {
		mActiveUids.clear();
		}
		mActiveUids.onActiveUidsCleared();
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		@Override
		public void onUidProcStateChanged(int uid, int procState) {
		synchronized (mGlobalLockWithoutBoost) {
		if (mActiveUids.get(uid) != null) {
		mActiveUids.put(uid, procState);
		}
		}
		mActiveUids.onUidProcStateChanged(uid, procState);
		}

		@Override

services/core/java/com/android/server/wm/MirrorActiveUids.java

0 → 100644

+53 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2019 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.wm;

		import static android.app.ActivityManager.PROCESS_STATE_NONEXISTENT;

		import android.util.SparseIntArray;

		/**
		* This is a partial mirror of {@link @com.android.server.am.ActiveUids}. It is already thread
		* safe so the heavy service lock is not needed when updating state from activity manager (oom
		* adjustment) or getting state from window manager (background start check).
		*/
		class MirrorActiveUids {
		private SparseIntArray mUidStates = new SparseIntArray();

		synchronized void onUidActive(int uid, int procState) {
		mUidStates.put(uid, procState);
		}

		synchronized void onUidInactive(int uid) {
		mUidStates.delete(uid);
		}

		synchronized void onActiveUidsCleared() {
		mUidStates.clear();
		}

		synchronized void onUidProcStateChanged(int uid, int procState) {
		final int index = mUidStates.indexOfKey(uid);
		if (index >= 0) {
		mUidStates.setValueAt(index, procState);
		}
		}

		synchronized int getUidState(int uid) {
		return mUidStates.get(uid, PROCESS_STATE_NONEXISTENT);
		}
		}

services/core/java/com/android/server/wm/WindowProcessController.java

+11 −0

Original line number	Diff line number	Diff line
		@@ -57,6 +57,7 @@ import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.app.HeavyWeightSwitcherActivity;
		import com.android.internal.util.function.pooled.PooledLambda;
		import com.android.server.Watchdog;
		import com.android.server.wm.ActivityTaskManagerService.HotPath;

		import java.io.IOException;
		import java.io.PrintWriter;
		@@ -408,12 +409,14 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		return null;
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		public void addPackage(String packageName) {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		mPkgList.add(packageName);
		}
		}

		@HotPath(caller = HotPath.PROCESS_CHANGE)
		public void clearPackageList() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		mPkgList.clear();
		@@ -441,12 +444,14 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		mActivities.clear();
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public boolean hasActivities() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		return !mActivities.isEmpty();
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public boolean hasVisibleActivities() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		for (int i = mActivities.size() - 1; i >= 0; --i) {
		@@ -459,6 +464,7 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		return false;
		}

		@HotPath(caller = HotPath.LRU_UPDATE)
		public boolean hasActivitiesOrRecentTasks() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		return !mActivities.isEmpty() \|\| !mRecentTasks.isEmpty();
		@@ -670,6 +676,7 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		void onOtherActivity();
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public int computeOomAdjFromActivities(int minTaskLayer, ComputeOomAdjCallback callback) {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		final int activitiesSize = mActivities.size();
		@@ -903,6 +910,7 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		mRecentTasks.remove(task);
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public boolean hasRecentTasks() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		return !mRecentTasks.isEmpty();
		@@ -966,18 +974,21 @@ public class WindowProcessController extends ConfigurationContainer<Configuratio
		return false;
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public void onTopProcChanged() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		mAtm.mVrController.onTopProcChangedLocked(this);
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public boolean isHomeProcess() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		return this == mAtm.mHomeProcess;
		}
		}

		@HotPath(caller = HotPath.OOM_ADJUSTMENT)
		public boolean isPreviousProcess() {
		synchronized (mAtm.mGlobalLockWithoutBoost) {
		return this == mAtm.mPreviousProcess;

services/tests/wmtests/src/com/android/server/wm/ActivityStarterTests.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -661,8 +661,8 @@ public class ActivityStarterTests extends ActivityTestsBase {
		doReturn(realCallingUidHasVisibleWindow).when(mService.mWindowManager.mRoot)
		.isAnyNonToastWindowVisibleForUid(realCallingUid);
		// process importance
		doReturn(callingUidProcState).when(mService).getUidStateLocked(callingUid);
		doReturn(realCallingUidProcState).when(mService).getUidStateLocked(realCallingUid);
		doReturn(callingUidProcState).when(mService).getUidState(callingUid);
		doReturn(realCallingUidProcState).when(mService).getUidState(realCallingUid);
		// foreground activities
		final IApplicationThread caller = mock(IApplicationThread.class);
		final ApplicationInfo ai = new ApplicationInfo();