Merge "BatteryStats: Cleanup external stats collection" (57fef233) · Commits · e / os / android_frameworks_base

core/java/android/os/SynchronousResultReceiver.java

+14 −0

Original line number	Original line	Diff line number	Diff line
	@@ -43,9 +43,19 @@ public class SynchronousResultReceiver extends ResultReceiver {
	}		}

	private final CompletableFuture<Result> mFuture = new CompletableFuture<>();		private final CompletableFuture<Result> mFuture = new CompletableFuture<>();
			private final String mName;

	public SynchronousResultReceiver() {		public SynchronousResultReceiver() {
	super((Handler) null);		super((Handler) null);
			mName = null;
			}

			/**
			* @param name Name for logging purposes
			*/
			public SynchronousResultReceiver(String name) {
			super((Handler) null);
			mName = name;
	}		}

	@Override		@Override
	@@ -54,6 +64,10 @@ public class SynchronousResultReceiver extends ResultReceiver {
	mFuture.complete(new Result(resultCode, resultData));		mFuture.complete(new Result(resultCode, resultData));
	}		}

			public String getName() {
			return mName;
			}

	/**		/**
	* Blocks waiting for the result from the remote client.		* Blocks waiting for the result from the remote client.
	*		*

core/java/com/android/internal/os/BatteryStatsImpl.java

+14 −12

Original line number	Original line	Diff line number	Diff line
	@@ -95,6 +95,7 @@ import java.util.Calendar;
	import java.util.HashMap;		import java.util.HashMap;
	import java.util.Iterator;		import java.util.Iterator;
	import java.util.Map;		import java.util.Map;
			import java.util.concurrent.Future;
	import java.util.concurrent.atomic.AtomicInteger;		import java.util.concurrent.atomic.AtomicInteger;
	import java.util.concurrent.locks.ReentrantLock;		import java.util.concurrent.locks.ReentrantLock;

	@@ -255,12 +256,12 @@ public class BatteryStatsImpl extends BatteryStats {
	int UPDATE_BT = 0x08;		int UPDATE_BT = 0x08;
	int UPDATE_ALL = UPDATE_CPU \| UPDATE_WIFI \| UPDATE_RADIO \| UPDATE_BT;		int UPDATE_ALL = UPDATE_CPU \| UPDATE_WIFI \| UPDATE_RADIO \| UPDATE_BT;

	void scheduleSync(String reason, int flags);		Future<?> scheduleSync(String reason, int flags);
	void scheduleCpuSyncDueToRemovedUid(int uid);		Future<?> scheduleCpuSyncDueToRemovedUid(int uid);
	}		}

	public final MyHandler mHandler;		public final MyHandler mHandler;
	private final ExternalStatsSync mExternalSync;		private ExternalStatsSync mExternalSync = null;

	private BatteryCallback mCallback;		private BatteryCallback mCallback;

	@@ -647,7 +648,6 @@ public class BatteryStatsImpl extends BatteryStats {
	mCheckinFile = null;		mCheckinFile = null;
	mDailyFile = null;		mDailyFile = null;
	mHandler = null;		mHandler = null;
	mExternalSync = null;
	mPlatformIdleStateCallback = null;		mPlatformIdleStateCallback = null;
	clearHistoryLocked();		clearHistoryLocked();
	}		}
	@@ -8614,17 +8614,16 @@ public class BatteryStatsImpl extends BatteryStats {
	return mCpuFreqs;		return mCpuFreqs;
	}		}

	public BatteryStatsImpl(File systemDir, Handler handler, ExternalStatsSync externalSync) {		public BatteryStatsImpl(File systemDir, Handler handler) {
	this(new SystemClocks(), systemDir, handler, externalSync, null);		this(new SystemClocks(), systemDir, handler, null);
	}		}

	public BatteryStatsImpl(File systemDir, Handler handler, ExternalStatsSync externalSync,		public BatteryStatsImpl(File systemDir, Handler handler, PlatformIdleStateCallback cb) {
	PlatformIdleStateCallback cb) {		this(new SystemClocks(), systemDir, handler, cb);
	this(new SystemClocks(), systemDir, handler, externalSync, cb);
	}		}

	public BatteryStatsImpl(Clocks clocks, File systemDir, Handler handler,		public BatteryStatsImpl(Clocks clocks, File systemDir, Handler handler,
	ExternalStatsSync externalSync, PlatformIdleStateCallback cb) {		PlatformIdleStateCallback cb) {
	init(clocks);		init(clocks);

	if (systemDir != null) {		if (systemDir != null) {
	@@ -8635,7 +8634,6 @@ public class BatteryStatsImpl extends BatteryStats {
	}		}
	mCheckinFile = new AtomicFile(new File(systemDir, "batterystats-checkin.bin"));		mCheckinFile = new AtomicFile(new File(systemDir, "batterystats-checkin.bin"));
	mDailyFile = new AtomicFile(new File(systemDir, "batterystats-daily.xml"));		mDailyFile = new AtomicFile(new File(systemDir, "batterystats-daily.xml"));
	mExternalSync = externalSync;
	mHandler = new MyHandler(handler.getLooper());		mHandler = new MyHandler(handler.getLooper());
	mStartCount++;		mStartCount++;
	mScreenOnTimer = new StopwatchTimer(mClocks, null, -1, null, mOnBatteryTimeBase);		mScreenOnTimer = new StopwatchTimer(mClocks, null, -1, null, mOnBatteryTimeBase);
	@@ -8762,6 +8760,10 @@ public class BatteryStatsImpl extends BatteryStats {
	}		}
	}		}

			public void setExternalStatsSyncLocked(ExternalStatsSync sync) {
			mExternalSync = sync;
			}

	public void updateDailyDeadlineLocked() {		public void updateDailyDeadlineLocked() {
	// Get the current time.		// Get the current time.
	long currentTime = mDailyStartTime = System.currentTimeMillis();		long currentTime = mDailyStartTime = System.currentTimeMillis();
	@@ -9767,7 +9769,7 @@ public class BatteryStatsImpl extends BatteryStats {
	return;		return;
	}		}

	final long elapsedRealtimeMs = SystemClock.elapsedRealtime();		final long elapsedRealtimeMs = mClocks.elapsedRealtime();
	long radioTime = mMobileRadioActivePerAppTimer.getTimeSinceMarkLocked(		long radioTime = mMobileRadioActivePerAppTimer.getTimeSinceMarkLocked(
	elapsedRealtimeMs * 1000);		elapsedRealtimeMs * 1000);
	mMobileRadioActivePerAppTimer.setMark(elapsedRealtimeMs);		mMobileRadioActivePerAppTimer.setMark(elapsedRealtimeMs);

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

+2 −2

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

0 → 100644

+388 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* Copyright (C) 2017 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 android.annotation.Nullable;
			import android.bluetooth.BluetoothActivityEnergyInfo;
			import android.bluetooth.BluetoothAdapter;
			import android.content.Context;
			import android.net.wifi.IWifiManager;
			import android.net.wifi.WifiActivityEnergyInfo;
			import android.os.BatteryStats;
			import android.os.Parcelable;
			import android.os.RemoteException;
			import android.os.ServiceManager;
			import android.os.SynchronousResultReceiver;
			import android.os.SystemClock;
			import android.telephony.ModemActivityInfo;
			import android.telephony.TelephonyManager;
			import android.util.IntArray;
			import android.util.Slog;
			import android.util.TimeUtils;

			import com.android.internal.annotations.GuardedBy;
			import com.android.internal.os.BatteryStatsImpl;

			import libcore.util.EmptyArray;

			import java.util.concurrent.ExecutorService;
			import java.util.concurrent.Executors;
			import java.util.concurrent.Future;
			import java.util.concurrent.ThreadFactory;
			import java.util.concurrent.TimeoutException;

			/**
			* A Worker that fetches data from external sources (WiFi controller, bluetooth chipset) on a
			* dedicated thread and updates BatteryStatsImpl with that information.
			*
			* As much work as possible is done without holding the BatteryStatsImpl lock, and only the
			* readily available data is pushed into BatteryStatsImpl with the lock held.
			*/
			class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync {
			private static final String TAG = "BatteryExternalStatsWorker";
			private static final boolean DEBUG = false;

			/**
			* How long to wait on an individual subsystem to return its stats.
			*/
			private static final long EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS = 2000;

			// There is some accuracy error in wifi reports so allow some slop in the results.
			private static final long MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS = 750;

			private final ExecutorService mExecutorService = Executors.newSingleThreadExecutor(
			(ThreadFactory) r -> {
			Thread t = new Thread(r, "batterystats-worker");
			t.setPriority(Thread.NORM_PRIORITY);
			return t;
			});

			private final Context mContext;
			private final BatteryStatsImpl mStats;

			@GuardedBy("this")
			private int mUpdateFlags = 0;

			@GuardedBy("this")
			private Future<?> mCurrentFuture = null;

			@GuardedBy("this")
			private String mCurrentReason = null;

			@GuardedBy("this")
			private final IntArray mUidsToRemove = new IntArray();

			private final Object mWorkerLock = new Object();

			@GuardedBy("mWorkerLock")
			private IWifiManager mWifiManager = null;

			@GuardedBy("mWorkerLock")
			private TelephonyManager mTelephony = null;

			// WiFi keeps an accumulated total of stats, unlike Bluetooth.
			// Keep the last WiFi stats so we can compute a delta.
			@GuardedBy("mWorkerLock")
			private WifiActivityEnergyInfo mLastInfo =
			new WifiActivityEnergyInfo(0, 0, 0, new long[]{0}, 0, 0, 0);

			BatteryExternalStatsWorker(Context context, BatteryStatsImpl stats) {
			mContext = context;
			mStats = stats;
			}

			@Override
			public synchronized Future<?> scheduleSync(String reason, int flags) {
			return scheduleSyncLocked(reason, flags);
			}

			@Override
			public synchronized Future<?> scheduleCpuSyncDueToRemovedUid(int uid) {
			mUidsToRemove.add(uid);
			return scheduleSyncLocked("remove-uid", UPDATE_CPU);
			}

			public synchronized Future<?> scheduleWrite() {
			scheduleSyncLocked("write", UPDATE_ALL);
			// Since we use a single threaded executor, we can assume the next scheduled task's
			// Future finishes after the sync.
			return mExecutorService.submit(mWriteTask);
			}

			/**
			* Schedules a task to run on the BatteryExternalStatsWorker thread. If scheduling more work
			* within the task, never wait on the resulting Future. This will result in a deadlock.
			*/
			public synchronized void scheduleRunnable(Runnable runnable) {
			mExecutorService.submit(runnable);
			}

			public void shutdown() {
			mExecutorService.shutdownNow();
			}

			private Future<?> scheduleSyncLocked(String reason, int flags) {
			if (mCurrentFuture == null) {
			mUpdateFlags = flags;
			mCurrentReason = reason;
			mCurrentFuture = mExecutorService.submit(mSyncTask);
			}
			mUpdateFlags \|= flags;
			return mCurrentFuture;
			}

			private final Runnable mSyncTask = new Runnable() {
			@Override
			public void run() {
			// Capture a snapshot of the state we are meant to process.
			final int updateFlags;
			final String reason;
			final int[] uidsToRemove;
			synchronized (BatteryExternalStatsWorker.this) {
			updateFlags = mUpdateFlags;
			reason = mCurrentReason;
			uidsToRemove = mUidsToRemove.size() > 0 ? mUidsToRemove.toArray() : EmptyArray.INT;
			mUpdateFlags = 0;
			mCurrentReason = null;
			mUidsToRemove.clear();
			mCurrentFuture = null;
			}

			synchronized (mWorkerLock) {
			if (DEBUG) {
			Slog.d(TAG, "begin updateExternalStatsSync reason=" + reason);
			}
			try {
			updateExternalStatsLocked(reason, updateFlags);
			} finally {
			if (DEBUG) {
			Slog.d(TAG, "end updateExternalStatsSync");
			}
			}
			}

			// Clean up any UIDs if necessary.
			synchronized (mStats) {
			for (int uid : uidsToRemove) {
			mStats.removeIsolatedUidLocked(uid);
			}
			}
			}
			};

			private final Runnable mWriteTask = new Runnable() {
			@Override
			public void run() {
			synchronized (mStats) {
			mStats.writeAsyncLocked();
			}
			}
			};

			private void updateExternalStatsLocked(final String reason, int updateFlags) {
			// We will request data from external processes asynchronously, and wait on a timeout.
			SynchronousResultReceiver wifiReceiver = null;
			SynchronousResultReceiver bluetoothReceiver = null;
			SynchronousResultReceiver modemReceiver = null;

			if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_WIFI) != 0) {
			// We were asked to fetch WiFi data.
			if (mWifiManager == null) {
			mWifiManager = IWifiManager.Stub.asInterface(ServiceManager.getService(
			Context.WIFI_SERVICE));
			}

			if (mWifiManager != null) {
			try {
			wifiReceiver = new SynchronousResultReceiver("wifi");
			mWifiManager.requestActivityInfo(wifiReceiver);
			} catch (RemoteException e) {
			// Oh well.
			}
			}
			}

			if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_BT) != 0) {
			// We were asked to fetch Bluetooth data.
			final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
			if (adapter != null) {
			bluetoothReceiver = new SynchronousResultReceiver("bluetooth");
			adapter.requestControllerActivityEnergyInfo(bluetoothReceiver);
			}
			}

			if ((updateFlags & BatteryStatsImpl.ExternalStatsSync.UPDATE_RADIO) != 0) {
			// We were asked to fetch Telephony data.
			if (mTelephony == null) {
			mTelephony = TelephonyManager.from(mContext);
			}

			if (mTelephony != null) {
			modemReceiver = new SynchronousResultReceiver("telephony");
			mTelephony.requestModemActivityInfo(modemReceiver);
			}
			}

			final WifiActivityEnergyInfo wifiInfo = awaitControllerInfo(wifiReceiver);
			final BluetoothActivityEnergyInfo bluetoothInfo = awaitControllerInfo(bluetoothReceiver);
			final ModemActivityInfo modemInfo = awaitControllerInfo(modemReceiver);

			synchronized (mStats) {
			mStats.addHistoryEventLocked(
			SystemClock.elapsedRealtime(),
			SystemClock.uptimeMillis(),
			BatteryStats.HistoryItem.EVENT_COLLECT_EXTERNAL_STATS,
			reason, 0);

			if ((updateFlags & UPDATE_CPU) != 0) {
			mStats.updateCpuTimeLocked(true /* updateCpuFreqData */);
			mStats.updateKernelWakelocksLocked();
			mStats.updateKernelMemoryBandwidthLocked();
			}

			if (bluetoothInfo != null) {
			if (bluetoothInfo.isValid()) {
			mStats.updateBluetoothStateLocked(bluetoothInfo);
			} else {
			Slog.e(TAG, "bluetooth info is invalid: " + bluetoothInfo);
			}
			}
			}

			// WiFi and Modem state are updated without the mStats lock held, because they
			// do some network stats retrieval before internally grabbing the mStats lock.

			if (wifiInfo != null) {
			if (wifiInfo.isValid()) {
			mStats.updateWifiState(extractDeltaLocked(wifiInfo));
			} else {
			Slog.e(TAG, "wifi info is invalid: " + wifiInfo);
			}
			}

			if (modemInfo != null) {
			if (modemInfo.isValid()) {
			mStats.updateMobileRadioState(modemInfo);
			} else {
			Slog.e(TAG, "modem info is invalid: " + modemInfo);
			}
			}
			}

			/**
			* Helper method to extract the Parcelable controller info from a
			* SynchronousResultReceiver.
			*/
			private static <T extends Parcelable> T awaitControllerInfo(
			@Nullable SynchronousResultReceiver receiver) {
			if (receiver == null) {
			return null;
			}

			try {
			final SynchronousResultReceiver.Result result =
			receiver.awaitResult(EXTERNAL_STATS_SYNC_TIMEOUT_MILLIS);
			if (result.bundle != null) {
			// This is the final destination for the Bundle.
			result.bundle.setDefusable(true);

			final T data = result.bundle.getParcelable(
			BatteryStats.RESULT_RECEIVER_CONTROLLER_KEY);
			if (data != null) {
			return data;
			}
			}
			Slog.e(TAG, "no controller energy info supplied for " + receiver.getName());
			} catch (TimeoutException e) {
			Slog.w(TAG, "timeout reading " + receiver.getName() + " stats");
			}
			return null;
			}

			private WifiActivityEnergyInfo extractDeltaLocked(WifiActivityEnergyInfo latest) {
			final long timePeriodMs = latest.mTimestamp - mLastInfo.mTimestamp;
			final long lastIdleMs = mLastInfo.mControllerIdleTimeMs;
			final long lastTxMs = mLastInfo.mControllerTxTimeMs;
			final long lastRxMs = mLastInfo.mControllerRxTimeMs;
			final long lastEnergy = mLastInfo.mControllerEnergyUsed;

			// We will modify the last info object to be the delta, and store the new
			// WifiActivityEnergyInfo object as our last one.
			final WifiActivityEnergyInfo delta = mLastInfo;
			delta.mTimestamp = latest.getTimeStamp();
			delta.mStackState = latest.getStackState();

			final long txTimeMs = latest.mControllerTxTimeMs - lastTxMs;
			final long rxTimeMs = latest.mControllerRxTimeMs - lastRxMs;
			final long idleTimeMs = latest.mControllerIdleTimeMs - lastIdleMs;

			if (txTimeMs < 0 \|\| rxTimeMs < 0) {
			// The stats were reset by the WiFi system (which is why our delta is negative).
			// Returns the unaltered stats.
			delta.mControllerEnergyUsed = latest.mControllerEnergyUsed;
			delta.mControllerRxTimeMs = latest.mControllerRxTimeMs;
			delta.mControllerTxTimeMs = latest.mControllerTxTimeMs;
			delta.mControllerIdleTimeMs = latest.mControllerIdleTimeMs;
			Slog.v(TAG, "WiFi energy data was reset, new WiFi energy data is " + delta);
			} else {
			final long totalActiveTimeMs = txTimeMs + rxTimeMs;
			long maxExpectedIdleTimeMs;
			if (totalActiveTimeMs > timePeriodMs) {
			// Cap the max idle time at zero since the active time consumed the whole time
			maxExpectedIdleTimeMs = 0;
			if (totalActiveTimeMs > timePeriodMs + MAX_WIFI_STATS_SAMPLE_ERROR_MILLIS) {
			StringBuilder sb = new StringBuilder();
			sb.append("Total Active time ");
			TimeUtils.formatDuration(totalActiveTimeMs, sb);
			sb.append(" is longer than sample period ");
			TimeUtils.formatDuration(timePeriodMs, sb);
			sb.append(".\n");
			sb.append("Previous WiFi snapshot: ").append("idle=");
			TimeUtils.formatDuration(lastIdleMs, sb);
			sb.append(" rx=");
			TimeUtils.formatDuration(lastRxMs, sb);
			sb.append(" tx=");
			TimeUtils.formatDuration(lastTxMs, sb);
			sb.append(" e=").append(lastEnergy);
			sb.append("\n");
			sb.append("Current WiFi snapshot: ").append("idle=");
			TimeUtils.formatDuration(latest.mControllerIdleTimeMs, sb);
			sb.append(" rx=");
			TimeUtils.formatDuration(latest.mControllerRxTimeMs, sb);
			sb.append(" tx=");
			TimeUtils.formatDuration(latest.mControllerTxTimeMs, sb);
			sb.append(" e=").append(latest.mControllerEnergyUsed);
			Slog.wtf(TAG, sb.toString());
			}
			} else {
			maxExpectedIdleTimeMs = timePeriodMs - totalActiveTimeMs;
			}
			// These times seem to be the most reliable.
			delta.mControllerTxTimeMs = txTimeMs;
			delta.mControllerRxTimeMs = rxTimeMs;
			// WiFi calculates the idle time as a difference from the on time and the various
			// Rx + Tx times. There seems to be some missing time there because this sometimes
			// becomes negative. Just cap it at 0 and ensure that it is less than the expected idle
			// time from the difference in timestamps.
			// b/21613534
			delta.mControllerIdleTimeMs = Math.min(maxExpectedIdleTimeMs, Math.max(0, idleTimeMs));
			delta.mControllerEnergyUsed = Math.max(0, latest.mControllerEnergyUsed - lastEnergy);
			}

			mLastInfo = latest;
			return delta;
			}
			}

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

+66 −385

File changed.

Preview size limit exceeded, changes collapsed.

Original line number	Original line	Diff line number	Diff line
	@@ -2743,7 +2743,7 @@ public class ActivityManagerService extends IActivityManager.Stub
	File dataDir = Environment.getDataDirectory();		File dataDir = Environment.getDataDirectory();
	File systemDir = new File(dataDir, "system");		File systemDir = new File(dataDir, "system");
	systemDir.mkdirs();		systemDir.mkdirs();
	mBatteryStatsService = new BatteryStatsService(systemDir, mHandler);		mBatteryStatsService = new BatteryStatsService(systemContext, systemDir, mHandler);
	mBatteryStatsService.getActiveStatistics().readLocked();		mBatteryStatsService.getActiveStatistics().readLocked();
	mBatteryStatsService.scheduleWriteToDisk();		mBatteryStatsService.scheduleWriteToDisk();
	mOnBattery = DEBUG_POWER ? true		mOnBattery = DEBUG_POWER ? true
	@@ -2846,7 +2846,7 @@ public class ActivityManagerService extends IActivityManager.Stub
	removeAllProcessGroups();		removeAllProcessGroups();
	mProcessCpuThread.start();		mProcessCpuThread.start();

	mBatteryStatsService.publish(mContext);		mBatteryStatsService.publish();
	mAppOpsService.publish(mContext);		mAppOpsService.publish(mContext);
	Slog.d("AppOps", "AppOpsService published");		Slog.d("AppOps", "AppOpsService published");
	LocalServices.addService(ActivityManagerInternal.class, new LocalService());		LocalServices.addService(ActivityManagerInternal.class, new LocalService());