BatteryStats: Cleanup external stats collection (b3a1badc) · Commits · e / os / android_frameworks_base

core/java/android/os/SynchronousResultReceiver.java

+14 −0

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

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

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

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

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

		public String getName() {
		return mName;
		}

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

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

+14 −12

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

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

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

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

		private BatteryCallback mCallback;

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

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

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

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

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

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

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

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

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

+2 −2

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

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

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

0 → 100644

+388 −0

Original line number	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.