From 782a906e7149b190f2d4efc532e4568953c03ebf Mon Sep 17 00:00:00 2001 From: Michael Wachenschwanz Date: Mon, 13 Sep 2021 21:45:53 -0700 Subject: [PATCH] Collect data from multiple DISPLAY EnergyConsumers Update MeasuredEnergySnapshot and BatteryExternalStatsWorker to handle multiple Display EnergyConsumers. Note: Utilizing the energy consumer data will occur in a follow up CL. Bug: 194107383 Test: atest FrameworksServicesTests:com.android.server.am.MeasuredEnergySnapshotTest Test: atest FrameworksServicesTests:BatteryExternalStatsWorkerTes Change-Id: Ic457b799c0e4ec78e83c1c9559dcfd38027f119a --- .../server/am/BatteryExternalStatsWorker.java | 11 +++++---- .../server/am/MeasuredEnergySnapshot.java | 11 +++++++-- .../am/BatteryExternalStatsWorkerTest.java | 23 +++++++++++++------ .../server/am/MeasuredEnergySnapshotTest.java | 16 ++++++------- 4 files changed, 39 insertions(+), 22 deletions(-) diff --git a/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java b/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java index 7ba032f683b85..e9aa3be8b403d 100644 --- a/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java +++ b/services/core/java/com/android/server/am/BatteryExternalStatsWorker.java @@ -659,11 +659,13 @@ class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync { // Inform mStats about each applicable measured energy (unless addressed elsewhere). if (measuredEnergyDeltas != null) { - final long displayChargeUC = measuredEnergyDeltas.displayChargeUC; - if (displayChargeUC != MeasuredEnergySnapshot.UNAVAILABLE) { + final long[] displayChargeUC = measuredEnergyDeltas.displayChargeUC; + if (displayChargeUC != null && displayChargeUC.length > 0) { + // TODO (b/194107383): pass all display ordinals to mStats. + final long primaryDisplayChargeUC = displayChargeUC[0]; // If updating, pass in what BatteryExternalStatsWorker thinks screenState is. - mStats.updateDisplayMeasuredEnergyStatsLocked(displayChargeUC, screenState, - elapsedRealtime); + mStats.updateDisplayMeasuredEnergyStatsLocked(primaryDisplayChargeUC, + screenState, elapsedRealtime); } final long gnssChargeUC = measuredEnergyDeltas.gnssChargeUC; @@ -948,6 +950,7 @@ class BatteryExternalStatsWorker implements BatteryStatsImpl.ExternalStatsSync { switch (consumer.type) { case EnergyConsumerType.OTHER: case EnergyConsumerType.CPU_CLUSTER: + case EnergyConsumerType.DISPLAY: break; default: Slog.w(TAG, "EnergyConsumer '" + consumer.name + "' has unexpected ordinal " diff --git a/services/core/java/com/android/server/am/MeasuredEnergySnapshot.java b/services/core/java/com/android/server/am/MeasuredEnergySnapshot.java index a9fca4f240269..0359aa531c644 100644 --- a/services/core/java/com/android/server/am/MeasuredEnergySnapshot.java +++ b/services/core/java/com/android/server/am/MeasuredEnergySnapshot.java @@ -49,6 +49,9 @@ public class MeasuredEnergySnapshot { /** Number of ordinals for {@link EnergyConsumerType#CPU_CLUSTER}. */ private final int mNumCpuClusterOrdinals; + /** Number of ordinals for {@link EnergyConsumerType#DISPLAY}. */ + private final int mNumDisplayOrdinals; + /** Number of ordinals for {@link EnergyConsumerType#OTHER}. */ private final int mNumOtherOrdinals; @@ -95,6 +98,7 @@ public class MeasuredEnergySnapshot { mNumCpuClusterOrdinals = calculateNumOrdinals(EnergyConsumerType.CPU_CLUSTER, idToConsumerMap); + mNumDisplayOrdinals = calculateNumOrdinals(EnergyConsumerType.DISPLAY, idToConsumerMap); mNumOtherOrdinals = calculateNumOrdinals(EnergyConsumerType.OTHER, idToConsumerMap); mAttributionSnapshots = new SparseArray<>(mNumOtherOrdinals); } @@ -108,7 +112,7 @@ public class MeasuredEnergySnapshot { public long[] cpuClusterChargeUC = null; /** The chargeUC for {@link EnergyConsumerType#DISPLAY}. */ - public long displayChargeUC = UNAVAILABLE; + public long[] displayChargeUC = null; /** The chargeUC for {@link EnergyConsumerType#GNSS}. */ public long gnssChargeUC = UNAVAILABLE; @@ -212,7 +216,10 @@ public class MeasuredEnergySnapshot { break; case EnergyConsumerType.DISPLAY: - output.displayChargeUC = deltaChargeUC; + if (output.displayChargeUC == null) { + output.displayChargeUC = new long[mNumDisplayOrdinals]; + } + output.displayChargeUC[ordinal] = deltaChargeUC; break; case EnergyConsumerType.GNSS: diff --git a/services/tests/servicestests/src/com/android/server/am/BatteryExternalStatsWorkerTest.java b/services/tests/servicestests/src/com/android/server/am/BatteryExternalStatsWorkerTest.java index 4a67ec71fcaaa..8a8a6246b73b1 100644 --- a/services/tests/servicestests/src/com/android/server/am/BatteryExternalStatsWorkerTest.java +++ b/services/tests/servicestests/src/com/android/server/am/BatteryExternalStatsWorkerTest.java @@ -74,15 +74,20 @@ public class BatteryExternalStatsWorkerTest { @Test public void testTargetedEnergyConsumerQuerying() { final int numCpuClusters = 4; + final int numDisplays = 5; final int numOther = 3; // Add some energy consumers used by BatteryExternalStatsWorker. final IntArray tempAllIds = new IntArray(); - final int displayId = mPowerStatsInternal.addEnergyConsumer(EnergyConsumerType.DISPLAY, 0, - "display"); - tempAllIds.add(displayId); - mPowerStatsInternal.incrementEnergyConsumption(displayId, 12345); + final int[] displayIds = new int[numDisplays]; + for (int i = 0; i < numDisplays; i++) { + displayIds[i] = mPowerStatsInternal.addEnergyConsumer( + EnergyConsumerType.DISPLAY, i, "display" + i); + tempAllIds.add(displayIds[i]); + mPowerStatsInternal.incrementEnergyConsumption(displayIds[i], 12345 + i); + } + Arrays.sort(displayIds); final int wifiId = mPowerStatsInternal.addEnergyConsumer(EnergyConsumerType.WIFI, 0, "wifi"); @@ -130,9 +135,13 @@ public class BatteryExternalStatsWorkerTest { final EnergyConsumerResult[] displayResults = mBatteryExternalStatsWorker.getMeasuredEnergyLocked(UPDATE_DISPLAY).getNow(null); - // Results should only have the display energy consumer - assertEquals(1, displayResults.length); - assertEquals(displayId, displayResults[0].id); + // Results should only have the cpu cluster energy consumers + final int[] receivedDisplayIds = new int[displayResults.length]; + for (int i = 0; i < displayResults.length; i++) { + receivedDisplayIds[i] = displayResults[i].id; + } + Arrays.sort(receivedDisplayIds); + assertArrayEquals(displayIds, receivedDisplayIds); final EnergyConsumerResult[] wifiResults = mBatteryExternalStatsWorker.getMeasuredEnergyLocked(UPDATE_WIFI).getNow(null); diff --git a/services/tests/servicestests/src/com/android/server/am/MeasuredEnergySnapshotTest.java b/services/tests/servicestests/src/com/android/server/am/MeasuredEnergySnapshotTest.java index 8c87506295f30..a0cbcadee8446 100644 --- a/services/tests/servicestests/src/com/android/server/am/MeasuredEnergySnapshotTest.java +++ b/services/tests/servicestests/src/com/android/server/am/MeasuredEnergySnapshotTest.java @@ -16,8 +16,6 @@ package com.android.server.am; -import static com.android.server.am.MeasuredEnergySnapshot.UNAVAILABLE; - import static com.google.common.truth.Truth.assertThat; import static org.junit.Assert.assertEquals; @@ -120,7 +118,7 @@ public final class MeasuredEnergySnapshotTest { // results0 MeasuredEnergyDeltaData delta = snapshot.updateAndGetDelta(RESULTS_0, VOLTAGE_0); if (delta != null) { // null is fine here. If non-null, it better be uninteresting though. - assertEquals(UNAVAILABLE, delta.displayChargeUC); + assertNull(delta.displayChargeUC); assertNull(delta.otherTotalChargeUC); assertNull(delta.otherUidChargesUC); } @@ -130,7 +128,7 @@ public final class MeasuredEnergySnapshotTest { assertNotNull(delta); long expectedChargeUC; expectedChargeUC = calculateChargeConsumedUC(14_000, VOLTAGE_0, 24_000, VOLTAGE_1); - assertEquals(expectedChargeUC, delta.displayChargeUC); + assertEquals(expectedChargeUC, delta.displayChargeUC[0]); assertNotNull(delta.otherTotalChargeUC); @@ -149,14 +147,14 @@ public final class MeasuredEnergySnapshotTest { delta = snapshot.updateAndGetDelta(RESULTS_2, VOLTAGE_2); assertNotNull(delta); expectedChargeUC = calculateChargeConsumedUC(24_000, VOLTAGE_1, 36_000, VOLTAGE_2); - assertEquals(expectedChargeUC, delta.displayChargeUC); + assertEquals(expectedChargeUC, delta.displayChargeUC[0]); assertNull(delta.otherUidChargesUC); assertNull(delta.otherTotalChargeUC); // results3 delta = snapshot.updateAndGetDelta(RESULTS_3, VOLTAGE_3); assertNotNull(delta); - assertEquals(UNAVAILABLE, delta.displayChargeUC); + assertNull(delta.displayChargeUC); assertNotNull(delta.otherTotalChargeUC); @@ -183,7 +181,7 @@ public final class MeasuredEnergySnapshotTest { delta = snapshot.updateAndGetDelta(RESULTS_4, VOLTAGE_4); assertNotNull(delta); expectedChargeUC = calculateChargeConsumedUC(36_000, VOLTAGE_2, 43_000, VOLTAGE_4); - assertEquals(expectedChargeUC, delta.displayChargeUC); + assertEquals(expectedChargeUC, delta.displayChargeUC[0]); assertNotNull(delta.otherTotalChargeUC); expectedChargeUC = calculateChargeConsumedUC(190_000, VOLTAGE_3, 290_000, VOLTAGE_4); @@ -210,7 +208,7 @@ public final class MeasuredEnergySnapshotTest { // results0 MeasuredEnergyDeltaData delta = snapshot.updateAndGetDelta(RESULTS_0, VOLTAGE_0); if (delta != null) { // null is fine here. If non-null, it better be uninteresting though. - assertEquals(UNAVAILABLE, delta.displayChargeUC); + assertNull(delta.displayChargeUC); assertNull(delta.otherTotalChargeUC); assertNull(delta.otherUidChargesUC); } @@ -220,7 +218,7 @@ public final class MeasuredEnergySnapshotTest { assertNotNull(delta); final long expectedChargeUC = calculateChargeConsumedUC(14_000, VOLTAGE_0, 24_000, VOLTAGE_1); - assertEquals(expectedChargeUC, delta.displayChargeUC); + assertEquals(expectedChargeUC, delta.displayChargeUC[0]); assertNull(delta.otherTotalChargeUC); // Although in the results, they're not in the idMap assertNull(delta.otherUidChargesUC); }