Merge "Fix RX/TX calculations for WiFi and BT" (3d2d4c82) · Commits · e / os / android_frameworks_base

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

+78 −54

Original line number	Diff line number	Diff line
		@@ -12758,6 +12758,8 @@ public class BatteryStatsImpl extends BatteryStats {

		SparseLongArray rxPackets = new SparseLongArray();
		SparseLongArray txPackets = new SparseLongArray();
		SparseLongArray rxTimesMs = new SparseLongArray();
		SparseLongArray txTimesMs = new SparseLongArray();
		long totalTxPackets = 0;
		long totalRxPackets = 0;
		if (delta != null) {
		@@ -12791,7 +12793,7 @@ public class BatteryStatsImpl extends BatteryStats {
		mNetworkPacketActivityCounters[NETWORK_WIFI_RX_DATA].addCountLocked(
		entry.rxPackets);

		add(rxPackets, uid, entry.rxPackets);
		rxPackets.incrementValue(uid, entry.rxPackets);

		// Sum the total number of packets so that the Rx Power can
		// be evenly distributed amongst the apps.
		@@ -12810,7 +12812,7 @@ public class BatteryStatsImpl extends BatteryStats {
		mNetworkPacketActivityCounters[NETWORK_WIFI_TX_DATA].addCountLocked(
		entry.txPackets);

		add(txPackets, uid, entry.txPackets);
		txPackets.incrementValue(uid, entry.txPackets);

		// Sum the total number of packets so that the Tx Power can
		// be evenly distributed amongst the apps.
		@@ -12934,12 +12936,9 @@ public class BatteryStatsImpl extends BatteryStats {
		+ scanTxTimeSinceMarkMs + " ms)");
		}

		ControllerActivityCounterImpl activityCounter =
		uid.getOrCreateWifiControllerActivityLocked();
		activityCounter.getOrCreateRxTimeCounter()
		.increment(scanRxTimeSinceMarkMs, elapsedRealtimeMs);
		activityCounter.getOrCreateTxTimeCounters()[0]
		.increment(scanTxTimeSinceMarkMs, elapsedRealtimeMs);
		rxTimesMs.incrementValue(uid.getUid(), scanRxTimeSinceMarkMs);
		txTimesMs.incrementValue(uid.getUid(), scanTxTimeSinceMarkMs);

		leftOverRxTimeMs -= scanRxTimeSinceMarkMs;
		leftOverTxTimeMs -= scanTxTimeSinceMarkMs;
		}
		@@ -12978,36 +12977,51 @@ public class BatteryStatsImpl extends BatteryStats {
		// Distribute the remaining Tx power appropriately between all apps that transmitted
		// packets.
		for (int i = 0; i < txPackets.size(); i++) {
		final Uid uid = getUidStatsLocked(txPackets.keyAt(i),
		elapsedRealtimeMs, uptimeMs);
		final int uid = txPackets.keyAt(i);
		final long myTxTimeMs = (txPackets.valueAt(i) * leftOverTxTimeMs)
		/ totalTxPackets;
		txTimesMs.incrementValue(uid, myTxTimeMs);
		}

		// Distribute the remaining Rx power appropriately between all apps that received
		// packets.
		for (int i = 0; i < rxPackets.size(); i++) {
		final int uid = rxPackets.keyAt(i);
		final long myRxTimeMs = (rxPackets.valueAt(i) * leftOverRxTimeMs)
		/ totalRxPackets;
		rxTimesMs.incrementValue(uid, myRxTimeMs);
		}

		for (int i = 0; i < txTimesMs.size(); i++) {
		final int uid = txTimesMs.keyAt(i);
		final long myTxTimeMs = txTimesMs.valueAt(i);
		if (DEBUG_ENERGY) {
		Slog.d(TAG, " TxTime for UID " + uid.getUid() + ": " + myTxTimeMs + " ms");
		Slog.d(TAG, " TxTime for UID " + uid + ": " + myTxTimeMs + " ms");
		}
		uid.getOrCreateWifiControllerActivityLocked().getOrCreateTxTimeCounters()[0]
		getUidStatsLocked(uid, elapsedRealtimeMs, uptimeMs)
		.getOrCreateWifiControllerActivityLocked()
		.getOrCreateTxTimeCounters()[0]
		.increment(myTxTimeMs, elapsedRealtimeMs);
		if (uidEstimatedConsumptionMah != null) {
		uidEstimatedConsumptionMah.incrementValue(uid.getUid(),
		uidEstimatedConsumptionMah.incrementValue(uid,
		mWifiPowerCalculator.calcPowerFromControllerDataMah(
		0, myTxTimeMs, 0));
		}
		}

		// Distribute the remaining Rx power appropriately between all apps that received
		// packets.
		for (int i = 0; i < rxPackets.size(); i++) {
		final Uid uid = getUidStatsLocked(rxPackets.keyAt(i),
		elapsedRealtimeMs, uptimeMs);
		final long myRxTimeMs = (rxPackets.valueAt(i) * leftOverRxTimeMs)
		/ totalRxPackets;
		for (int i = 0; i < rxTimesMs.size(); i++) {
		final int uid = rxTimesMs.keyAt(i);
		final long myRxTimeMs = rxTimesMs.valueAt(i);
		if (DEBUG_ENERGY) {
		Slog.d(TAG, " RxTime for UID " + uid.getUid() + ": " + myRxTimeMs + " ms");
		Slog.d(TAG, " RxTime for UID " + uid + ": " + myRxTimeMs + " ms");
		}
		uid.getOrCreateWifiControllerActivityLocked().getOrCreateRxTimeCounter()

		getUidStatsLocked(rxTimesMs.keyAt(i), elapsedRealtimeMs, uptimeMs)
		.getOrCreateWifiControllerActivityLocked()
		.getOrCreateRxTimeCounter()
		.increment(myRxTimeMs, elapsedRealtimeMs);
		if (uidEstimatedConsumptionMah != null) {
		uidEstimatedConsumptionMah.incrementValue(uid.getUid(),
		uidEstimatedConsumptionMah.incrementValue(uid,
		mWifiPowerCalculator.calcPowerFromControllerDataMah(
		myRxTimeMs, 0, 0));
		}
		@@ -13015,7 +13029,6 @@ public class BatteryStatsImpl extends BatteryStats {

		// Any left over power use will be picked up by the WiFi category in BatteryStatsHelper.


		// Update WiFi controller stats.
		mWifiActivity.getOrCreateRxTimeCounter().increment(
		info.getControllerRxDurationMillis(), elapsedRealtimeMs);
		@@ -13353,8 +13366,8 @@ public class BatteryStatsImpl extends BatteryStats {
		energy = info.getControllerEnergyUsed();
		if (!info.getUidTraffic().isEmpty()) {
		for (UidTraffic traffic : info.getUidTraffic()) {
		add(uidRxBytes, traffic.getUid(), traffic.getRxBytes());
		add(uidTxBytes, traffic.getUid(), traffic.getTxBytes());
		uidRxBytes.incrementValue(traffic.getUid(), traffic.getRxBytes());
		uidTxBytes.incrementValue(traffic.getUid(), traffic.getTxBytes());
		}
		}
		}
		@@ -13446,6 +13459,9 @@ public class BatteryStatsImpl extends BatteryStats {
		long leftOverRxTimeMs = rxTimeMs;
		long leftOverTxTimeMs = txTimeMs;

		final SparseLongArray rxTimesMs = new SparseLongArray(uidCount);
		final SparseLongArray txTimesMs = new SparseLongArray(uidCount);

		for (int i = 0; i < uidCount; i++) {
		final Uid u = mUidStats.valueAt(i);
		if (u.mBluetoothScanTimer == null) {
		@@ -13475,12 +13491,8 @@ public class BatteryStatsImpl extends BatteryStats {
		scanTimeTxSinceMarkMs = (txTimeMs * scanTimeTxSinceMarkMs) / totalScanTimeMs;
		}

		final ControllerActivityCounterImpl counter =
		u.getOrCreateBluetoothControllerActivityLocked();
		counter.getOrCreateRxTimeCounter()
		.increment(scanTimeRxSinceMarkMs, elapsedRealtimeMs);
		counter.getOrCreateTxTimeCounters()[0]
		.increment(scanTimeTxSinceMarkMs, elapsedRealtimeMs);
		rxTimesMs.incrementValue(u.getUid(), scanTimeRxSinceMarkMs);
		txTimesMs.incrementValue(u.getUid(), scanTimeTxSinceMarkMs);

		if (uidEstimatedConsumptionMah != null) {
		uidEstimatedConsumptionMah.incrementValue(u.getUid(),
		@@ -13544,29 +13556,45 @@ public class BatteryStatsImpl extends BatteryStats {

		if (totalRxBytes > 0 && rxBytes > 0) {
		final long timeRxMs = (leftOverRxTimeMs * rxBytes) / totalRxBytes;
		if (DEBUG_ENERGY) {
		Slog.d(TAG, "UID=" + uid + " rx_bytes=" + rxBytes + " rx_time=" + timeRxMs);
		rxTimesMs.incrementValue(uid, timeRxMs);
		}
		counter.getOrCreateRxTimeCounter().increment(timeRxMs, elapsedRealtimeMs);

		if (totalTxBytes > 0 && txBytes > 0) {
		final long timeTxMs = (leftOverTxTimeMs * txBytes) / totalTxBytes;
		txTimesMs.incrementValue(uid, timeTxMs);
		}
		}

		for (int i = 0; i < txTimesMs.size(); i++) {
		final int uid = txTimesMs.keyAt(i);
		final long myTxTimeMs = txTimesMs.valueAt(i);
		if (DEBUG_ENERGY) {
		Slog.d(TAG, " TxTime for UID " + uid + ": " + myTxTimeMs + " ms");
		}
		getUidStatsLocked(uid, elapsedRealtimeMs, uptimeMs)
		.getOrCreateBluetoothControllerActivityLocked()
		.getOrCreateTxTimeCounters()[0]
		.increment(myTxTimeMs, elapsedRealtimeMs);
		if (uidEstimatedConsumptionMah != null) {
		uidEstimatedConsumptionMah.incrementValue(u.getUid(),
		mBluetoothPowerCalculator.calculatePowerMah(timeRxMs, 0, 0));
		uidEstimatedConsumptionMah.incrementValue(uid,
		mBluetoothPowerCalculator.calculatePowerMah(0, myTxTimeMs, 0));
		}
		}

		if (totalTxBytes > 0 && txBytes > 0) {
		final long timeTxMs = (leftOverTxTimeMs * txBytes) / totalTxBytes;
		for (int i = 0; i < rxTimesMs.size(); i++) {
		final int uid = rxTimesMs.keyAt(i);
		final long myRxTimeMs = rxTimesMs.valueAt(i);
		if (DEBUG_ENERGY) {
		Slog.d(TAG, "UID=" + uid + " tx_bytes=" + txBytes + " tx_time=" + timeTxMs);
		Slog.d(TAG, " RxTime for UID " + uid + ": " + myRxTimeMs + " ms");
		}
		counter.getOrCreateTxTimeCounters()[0]
		.increment(timeTxMs, elapsedRealtimeMs);

		getUidStatsLocked(rxTimesMs.keyAt(i), elapsedRealtimeMs, uptimeMs)
		.getOrCreateBluetoothControllerActivityLocked()
		.getOrCreateRxTimeCounter()
		.increment(myRxTimeMs, elapsedRealtimeMs);
		if (uidEstimatedConsumptionMah != null) {
		uidEstimatedConsumptionMah.incrementValue(u.getUid(),
		mBluetoothPowerCalculator.calculatePowerMah(0, timeTxMs, 0));
		}
		uidEstimatedConsumptionMah.incrementValue(uid,
		mBluetoothPowerCalculator.calculatePowerMah(myRxTimeMs, 0, 0));
		}
		}
		}
		@@ -18156,8 +18184,4 @@ public class BatteryStatsImpl extends BatteryStats {
		pw.println();
		dumpMeasuredEnergyStatsLocked(pw);
		}

		private static void add(SparseLongArray array, int key, long delta) {
		array.put(key, array.get(key) + delta);
		}
		}

core/tests/coretests/src/com/android/internal/os/BluetoothPowerCalculatorTest.java

+55 −24

Original line number	Diff line number	Diff line
		@@ -26,6 +26,7 @@ import android.os.BatteryStats;
		import android.os.BatteryUsageStatsQuery;
		import android.os.Process;
		import android.os.UidBatteryConsumer;
		import android.os.WorkSource;

		import androidx.test.filters.SmallTest;
		import androidx.test.runner.AndroidJUnit4;
		@@ -52,6 +53,12 @@ public class BluetoothPowerCalculatorTest {

		@Test
		public void testTimerBasedModel() {
		BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();

		final WorkSource ws = new WorkSource(APP_UID);
		batteryStats.noteBluetoothScanStartedFromSourceLocked(ws, false, 0, 0);
		batteryStats.noteBluetoothScanStoppedFromSourceLocked(ws, false, 1000, 1000);

		setupBluetoothEnergyInfo(0, BatteryStats.POWER_DATA_UNAVAILABLE);

		BluetoothPowerCalculator calculator =
		@@ -59,8 +66,18 @@ public class BluetoothPowerCalculatorTest {

		mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator);

		assertCalculatedPower(0.08216, 0.18169, 0.26388, 0.26386,
		BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID),
		0.06944, 3000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(APP_UID),
		0.19444, 9000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getDeviceBatteryConsumer(),
		0.26388, 12000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getAppsBatteryConsumer(),
		0.26388, 12000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		}

		@Test
		@@ -136,8 +153,18 @@ public class BluetoothPowerCalculatorTest {
		mStatsRule.apply(new BatteryUsageStatsQuery.Builder().includePowerModels().build(),
		calculator);

		assertCalculatedPower(0.08216, 0.18169, 0.30030, 0.26386,
		BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID),
		0.08216, 3583, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(APP_UID),
		0.18169, 8416, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getDeviceBatteryConsumer(),
		0.30030, 12000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getAppsBatteryConsumer(),
		0.26386, 11999, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		}

		@Test
		@@ -150,8 +177,18 @@ public class BluetoothPowerCalculatorTest {

		mStatsRule.apply(calculator);

		assertCalculatedPower(0.10378, 0.22950, 0.33333, 0.33329,
		BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID),
		0.10378, 3583, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(APP_UID),
		0.22950, 8416, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		assertBluetoothPowerAndDuration(
		mStatsRule.getDeviceBatteryConsumer(),
		0.33333, 12000, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		assertBluetoothPowerAndDuration(
		mStatsRule.getAppsBatteryConsumer(),
		0.33329, 11999, BatteryConsumer.POWER_MODEL_MEASURED_ENERGY);
		}

		@Test
		@@ -228,8 +265,18 @@ public class BluetoothPowerCalculatorTest {

		mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator);

		assertCalculatedPower(0.08216, 0.18169, 0.26388, 0.26386,
		BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID),
		0.08216, 3583, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(APP_UID),
		0.18169, 8416, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getDeviceBatteryConsumer(),
		0.26388, 12000, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		assertBluetoothPowerAndDuration(
		mStatsRule.getAppsBatteryConsumer(),
		0.26386, 11999, BatteryConsumer.POWER_MODEL_POWER_PROFILE);
		}

		private void setupBluetoothEnergyInfo(long reportedEnergyUc, long consumedEnergyUc) {
		@@ -243,22 +290,6 @@ public class BluetoothPowerCalculatorTest {
		consumedEnergyUc, 1000, 1000);
		}

		private void assertCalculatedPower(double bluetoothUidPowerMah, double appPowerMah,
		double devicePowerMah, double allAppsPowerMah, int powerModelPowerProfile) {
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(Process.BLUETOOTH_UID),
		bluetoothUidPowerMah, 3583, powerModelPowerProfile);
		assertBluetoothPowerAndDuration(
		mStatsRule.getUidBatteryConsumer(APP_UID),
		appPowerMah, 8416, powerModelPowerProfile);
		assertBluetoothPowerAndDuration(
		mStatsRule.getDeviceBatteryConsumer(),
		devicePowerMah, 12000, powerModelPowerProfile);
		assertBluetoothPowerAndDuration(
		mStatsRule.getAppsBatteryConsumer(),
		allAppsPowerMah, 11999, powerModelPowerProfile);
		}

		private void assertBluetoothPowerAndDuration(@Nullable BatteryConsumer batteryConsumer,
		double powerMah, int durationMs, @BatteryConsumer.PowerModel int powerModel) {
		assertThat(batteryConsumer).isNotNull();

core/tests/coretests/src/com/android/internal/os/WifiPowerCalculatorTest.java

+7 −4

Original line number	Diff line number	Diff line
		@@ -92,7 +92,10 @@ public class WifiPowerCalculatorTest {
		final BatteryStatsImpl batteryStats = setupTestNetworkNumbers();
		final WifiActivityEnergyInfo energyInfo = setupPowerControllerBasedModelEnergyNumbersInfo();

		batteryStats.updateWifiState(energyInfo, POWER_DATA_UNAVAILABLE, 1000, 1000,
		batteryStats.noteWifiScanStartedLocked(APP_UID, 500, 500);
		batteryStats.noteWifiScanStoppedLocked(APP_UID, 1500, 1500);

		batteryStats.updateWifiState(energyInfo, POWER_DATA_UNAVAILABLE, 2000, 2000,
		mNetworkStatsManager);

		WifiPowerCalculator calculator = new WifiPowerCalculator(mStatsRule.getPowerProfile());
		@@ -100,15 +103,15 @@ public class WifiPowerCalculatorTest {

		UidBatteryConsumer uidConsumer = mStatsRule.getUidBatteryConsumer(APP_UID);
		assertThat(uidConsumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_WIFI))
		.isEqualTo(1423);
		.isEqualTo(2473);
		assertThat(uidConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
		.isWithin(PRECISION).of(0.2214666);
		.isWithin(PRECISION).of(0.3964);
		assertThat(uidConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI))
		.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);

		BatteryConsumer deviceConsumer = mStatsRule.getDeviceBatteryConsumer();
		assertThat(deviceConsumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_WIFI))
		.isEqualTo(4002);
		.isEqualTo(4001);
		assertThat(deviceConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_WIFI))
		.isWithin(PRECISION).of(0.86666);
		assertThat(deviceConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_WIFI))