Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update Screen and AmbientDisplay Power Calculators for multi-display

Browse Source 
Bug: 200239964
Test: atest ScreenPowerCalculatorTest
Test: atest AmbientDisplayPowerCalculatorTest
Change-Id: I45abcf872de7239040f84b26bd9aa2af07cfaa7c
This commit is contained in:
Michael Wachenschwanz
2021-09-28 11:23:38 -07:00
parent e031d50952
commit e280aaca38
6 changed files with 196 additions and 57 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
core/java/com/android/internal/os/AmbientDisplayPowerCalculator.java
View File

@@ -31,12 +31,15 @@ import java.util.List;
* Estimates power consumed by the ambient display
*/
public class AmbientDisplayPowerCalculator extends PowerCalculator {
private final UsageBasedPowerEstimator mPowerEstimator;
private final UsageBasedPowerEstimator[] mPowerEstimators;
public AmbientDisplayPowerCalculator(PowerProfile powerProfile) {
// TODO(b/200239964): update to support multidisplay.
mPowerEstimator = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0));
final int numDisplays = powerProfile.getNumDisplays();
mPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
for (int display = 0; display < numDisplays; display++) {
mPowerEstimators[display] = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, display));
}
}
/**
@@ -50,8 +53,8 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
final int powerModel = getPowerModel(measuredEnergyUC, query);
final long durationMs = calculateDuration(batteryStats, rawRealtimeUs,
BatteryStats.STATS_SINCE_CHARGED);
final double powerMah = getMeasuredOrEstimatedPower(powerModel,
measuredEnergyUC, mPowerEstimator, durationMs);
final double powerMah = calculateTotalPower(powerModel, batteryStats, rawRealtimeUs,
measuredEnergyUC);
builder.getAggregateBatteryConsumerBuilder(
BatteryUsageStats.AGGREGATE_BATTERY_CONSUMER_SCOPE_DEVICE)
.setUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY, durationMs)
@@ -71,9 +74,8 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
final long measuredEnergyUC = batteryStats.getScreenDozeMeasuredBatteryConsumptionUC();
final long durationMs = calculateDuration(batteryStats, rawRealtimeUs, statsType);
final int powerModel = getPowerModel(measuredEnergyUC);
final double powerMah = getMeasuredOrEstimatedPower(powerModel,
batteryStats.getScreenDozeMeasuredBatteryConsumptionUC(),
mPowerEstimator, durationMs);
final double powerMah = calculateTotalPower(powerModel, batteryStats, rawRealtimeUs,
measuredEnergyUC);
if (powerMah > 0) {
BatterySipper bs = new BatterySipper(BatterySipper.DrainType.AMBIENT_DISPLAY, null, 0);
bs.usagePowerMah = powerMah;
@@ -86,4 +88,26 @@ public class AmbientDisplayPowerCalculator extends PowerCalculator {
private long calculateDuration(BatteryStats batteryStats, long rawRealtimeUs, int statsType) {
return batteryStats.getScreenDozeTime(rawRealtimeUs, statsType) / 1000;
}
private double calculateTotalPower(@BatteryConsumer.PowerModel int powerModel,
BatteryStats batteryStats, long rawRealtimeUs, long consumptionUC) {
switch (powerModel) {
case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY:
return uCtoMah(consumptionUC);
case BatteryConsumer.POWER_MODEL_POWER_PROFILE:
default:
return calculateEstimatedPower(batteryStats, rawRealtimeUs);
}
}
private double calculateEstimatedPower(BatteryStats batteryStats, long rawRealtimeUs) {
final int numDisplays = mPowerEstimators.length;
double power = 0;
for (int display = 0; display < numDisplays; display++) {
final long dozeTime = batteryStats.getDisplayScreenDozeTime(display, rawRealtimeUs)
/ 1000;
power += mPowerEstimators[display].calculatePower(dozeTime);
}
return power;
}
}

26
core/java/com/android/internal/os/PowerCalculator.java
View File

@@ -132,32 +132,6 @@ public abstract class PowerCalculator {
: BatteryConsumer.POWER_MODEL_POWER_PROFILE;
}
/**
* Returns either the measured energy converted to mAh or a usage-based estimate.
*/
protected static double getMeasuredOrEstimatedPower(@BatteryConsumer.PowerModel int powerModel,
long measuredEnergyUC, UsageBasedPowerEstimator powerEstimator, long durationMs) {
switch (powerModel) {
case BatteryConsumer.POWER_MODEL_MEASURED_ENERGY:
return uCtoMah(measuredEnergyUC);
case BatteryConsumer.POWER_MODEL_POWER_PROFILE:
default:
return powerEstimator.calculatePower(durationMs);
}
}
/**
* Returns either the measured energy converted to mAh or a usage-based estimate.
*/
protected static double getMeasuredOrEstimatedPower(
long measuredEnergyUC, UsageBasedPowerEstimator powerEstimator, long durationMs) {
if (measuredEnergyUC != BatteryStats.POWER_DATA_UNAVAILABLE) {
return uCtoMah(measuredEnergyUC);
} else {
return powerEstimator.calculatePower(durationMs);
}
}
/**
* Prints formatted amount of power in milli-amp-hours.
*/

51
core/java/com/android/internal/os/ScreenPowerCalculator.java
View File

@@ -44,8 +44,8 @@ public class ScreenPowerCalculator extends PowerCalculator {
// Minimum amount of time the screen should be on to start smearing drain to apps
public static final long MIN_ACTIVE_TIME_FOR_SMEARING = 10 * DateUtils.MINUTE_IN_MILLIS;
private final UsageBasedPowerEstimator mScreenOnPowerEstimator;
private final UsageBasedPowerEstimator mScreenFullPowerEstimator;
private final UsageBasedPowerEstimator[] mScreenOnPowerEstimators;
private final UsageBasedPowerEstimator[] mScreenFullPowerEstimators;
private static class PowerAndDuration {
public long durationMs;
@@ -53,11 +53,16 @@ public class ScreenPowerCalculator extends PowerCalculator {
}
public ScreenPowerCalculator(PowerProfile powerProfile) {
// TODO(b/200239964): update to support multidisplay.
mScreenOnPowerEstimator = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, 0));
mScreenFullPowerEstimator = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 0));
final int numDisplays = powerProfile.getNumDisplays();
mScreenOnPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
mScreenFullPowerEstimators = new UsageBasedPowerEstimator[numDisplays];
for (int display = 0; display < numDisplays; display++) {
mScreenOnPowerEstimators[display] = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, display));
mScreenFullPowerEstimators[display] = new UsageBasedPowerEstimator(
powerProfile.getAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL,
display));
}
}
@Override
@@ -172,7 +177,7 @@ public class ScreenPowerCalculator extends PowerCalculator {
case BatteryConsumer.POWER_MODEL_POWER_PROFILE:
default:
totalPowerAndDuration.powerMah = calculateTotalPowerFromBrightness(batteryStats,
rawRealtimeUs, statsType, totalPowerAndDuration.durationMs);
rawRealtimeUs);
}
}
@@ -194,19 +199,25 @@ public class ScreenPowerCalculator extends PowerCalculator {
return batteryStats.getScreenOnTime(rawRealtimeUs, statsType) / 1000;
}
private double calculateTotalPowerFromBrightness(BatteryStats batteryStats, long rawRealtimeUs,
int statsType, long durationMs) {
double power = mScreenOnPowerEstimator.calculatePower(durationMs);
for (int i = 0; i < BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS; i++) {
final long brightnessTime =
batteryStats.getScreenBrightnessTime(i, rawRealtimeUs, statsType) / 1000;
final double binPowerMah = mScreenFullPowerEstimator.calculatePower(brightnessTime)
* (i + 0.5f) / BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS;
if (DEBUG && binPowerMah != 0) {
Slog.d(TAG, "Screen bin #" + i + ": time=" + brightnessTime
+ " power=" + formatCharge(binPowerMah));
private double calculateTotalPowerFromBrightness(BatteryStats batteryStats,
long rawRealtimeUs) {
final int numDisplays = mScreenOnPowerEstimators.length;
double power = 0;
for (int display = 0; display < numDisplays; display++) {
final long displayTime = batteryStats.getDisplayScreenOnTime(display, rawRealtimeUs)
/ 1000;
power += mScreenOnPowerEstimators[display].calculatePower(displayTime);
for (int bin = 0; bin < BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS; bin++) {
final long brightnessTime = batteryStats.getDisplayScreenBrightnessTime(display,
bin, rawRealtimeUs) / 1000;
final double binPowerMah = mScreenFullPowerEstimators[display].calculatePower(
brightnessTime) * (bin + 0.5f) / BatteryStats.NUM_SCREEN_BRIGHTNESS_BINS;
if (DEBUG && binPowerMah != 0) {
Slog.d(TAG, "Screen bin #" + bin + ": time=" + brightnessTime
+ " power=" + formatCharge(binPowerMah));
}
power += binPowerMah;
}
power += binPowerMah;
}
return power;
}

35
core/tests/coretests/src/com/android/internal/os/AmbientDisplayPowerCalculatorTest.java
View File

@@ -38,7 +38,8 @@ public class AmbientDisplayPowerCalculatorTest {
@Rule
public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule()
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0, 10.0);
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 0, 10.0)
.setNumDisplays(1);
@Test
public void testMeasuredEnergyBasedModel() {
@@ -96,4 +97,36 @@ public class AmbientDisplayPowerCalculatorTest {
assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
}
@Test
public void testPowerProfileBasedModel_multiDisplay() {
mStatsRule.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_AMBIENT, 1, 20.0)
.setNumDisplays(2);
BatteryStatsImpl stats = mStatsRule.getBatteryStats();
stats.noteScreenStateLocked(1, Display.STATE_OFF, 0, 0, 0);
stats.noteScreenStateLocked(0, Display.STATE_DOZE, 30 * MINUTE_IN_MS, 30 * MINUTE_IN_MS,
30 * MINUTE_IN_MS);
stats.noteScreenStateLocked(1, Display.STATE_DOZE, 90 * MINUTE_IN_MS, 90 * MINUTE_IN_MS,
90 * MINUTE_IN_MS);
stats.noteScreenStateLocked(0, Display.STATE_OFF, 120 * MINUTE_IN_MS, 120 * MINUTE_IN_MS,
120 * MINUTE_IN_MS);
stats.noteScreenStateLocked(1, Display.STATE_OFF, 150 * MINUTE_IN_MS, 150 * MINUTE_IN_MS,
150 * MINUTE_IN_MS);
AmbientDisplayPowerCalculator calculator =
new AmbientDisplayPowerCalculator(mStatsRule.getPowerProfile());
mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator);
BatteryConsumer consumer = mStatsRule.getDeviceBatteryConsumer();
// Duration should only be the union of
assertThat(consumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
.isEqualTo(120 * MINUTE_IN_MS);
assertThat(consumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
.isWithin(PRECISION).of(35.0);
assertThat(consumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_AMBIENT_DISPLAY))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
}
}

6
core/tests/coretests/src/com/android/internal/os/BatteryUsageStatsRule.java
View File

@@ -118,6 +118,12 @@ public class BatteryUsageStatsRule implements TestRule {
return this;
}
public BatteryUsageStatsRule setNumDisplays(int value) {
when(mPowerProfile.getNumDisplays()).thenReturn(value);
mBatteryStats.setDisplayCountLocked(value);
return this;
}
/** Call only after setting the power profile information. */
public BatteryUsageStatsRule initMeasuredEnergyStatsLocked() {
return initMeasuredEnergyStatsLocked(new String[0]);

93
core/tests/coretests/src/com/android/internal/os/ScreenPowerCalculatorTest.java
View File

@@ -42,11 +42,13 @@ public class ScreenPowerCalculatorTest {
private static final int APP_UID2 = Process.FIRST_APPLICATION_UID + 43;
private static final long MINUTE_IN_MS = 60 * 1000;
private static final long MINUTE_IN_US = 60 * 1000 * 1000;
private static final long HOUR_IN_MS = 60 * MINUTE_IN_MS;
@Rule
public final BatteryUsageStatsRule mStatsRule = new BatteryUsageStatsRule()
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, 0, 36.0)
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 0, 48.0);
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 0, 48.0)
.setNumDisplays(1);
@Test
public void testMeasuredEnergyBasedModel() {
@@ -197,6 +199,95 @@ public class ScreenPowerCalculatorTest {
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
}
@Test
public void testPowerProfileBasedModel_multiDisplay() {
mStatsRule.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_ON, 1, 60.0)
.setAveragePowerForOrdinal(POWER_GROUP_DISPLAY_SCREEN_FULL, 1, 100.0)
.setNumDisplays(2);
BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();
batteryStats.noteScreenStateLocked(0, Display.STATE_ON, 0, 0, 0);
batteryStats.noteScreenStateLocked(1, Display.STATE_OFF, 0, 0, 0);
batteryStats.noteScreenBrightnessLocked(0, 255, 0, 0);
setProcState(APP_UID1, ActivityManager.PROCESS_STATE_TOP, true,
0, 0);
batteryStats.noteScreenBrightnessLocked(0, 100, 5 * MINUTE_IN_MS, 5 * MINUTE_IN_MS);
batteryStats.noteScreenBrightnessLocked(0, 200, 10 * MINUTE_IN_MS, 10 * MINUTE_IN_MS);
setProcState(APP_UID1, ActivityManager.PROCESS_STATE_CACHED_EMPTY, false,
20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP, true,
20 * MINUTE_IN_MS, 20 * MINUTE_IN_MS);
batteryStats.noteScreenStateLocked(0, Display.STATE_OFF,
80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
batteryStats.noteScreenStateLocked(1, Display.STATE_ON, 80 * MINUTE_IN_MS,
80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
batteryStats.noteScreenBrightnessLocked(1, 20, 80 * MINUTE_IN_MS, 80 * MINUTE_IN_MS);
batteryStats.noteScreenBrightnessLocked(1, 250, 86 * MINUTE_IN_MS, 86 * MINUTE_IN_MS);
batteryStats.noteScreenBrightnessLocked(1, 75, 98 * MINUTE_IN_MS, 98 * MINUTE_IN_MS);
batteryStats.noteScreenStateLocked(1, Display.STATE_OFF, 110 * MINUTE_IN_MS,
110 * MINUTE_IN_MS, 110 * MINUTE_IN_MS);
setProcState(APP_UID2, ActivityManager.PROCESS_STATE_TOP_SLEEPING, false,
110 * MINUTE_IN_MS, 110 * MINUTE_IN_MS);
mStatsRule.setTime(120 * MINUTE_IN_US, 120 * MINUTE_IN_US);
ScreenPowerCalculator calculator =
new ScreenPowerCalculator(mStatsRule.getPowerProfile());
mStatsRule.apply(BatteryUsageStatsRule.POWER_PROFILE_MODEL_ONLY, calculator);
BatteryConsumer deviceConsumer = mStatsRule.getDeviceBatteryConsumer();
assertThat(deviceConsumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(110 * MINUTE_IN_MS);
// First display consumed 92 mAh.
// Second display ran for 0.5 hours at a base drain rate of 60 mA.
// 6 minutes (0.1 hours) spent in the first brightness level which drains an extra 10 mA.
// 12 minutes (0.2 hours) spent in the fifth brightness level which drains an extra 90 mA.
// 12 minutes (0.2 hours) spent in the second brightness level which drains an extra 30 mA.
// 92 + 60 * 0.5 + 10 * 0.1 + 90 * 0.2 + 30 * 0.2 = 147
assertThat(deviceConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isWithin(PRECISION).of(147);
assertThat(deviceConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
UidBatteryConsumer uid1 = mStatsRule.getUidBatteryConsumer(APP_UID1);
assertThat(uid1.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(20 * MINUTE_IN_MS);
// Uid1 took 20 out of the total of 110 min of foreground activity
// Uid1 charge = 20 / 110 * 147.0 = 23.0 mAh
assertThat(uid1.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isWithin(PRECISION).of(26.72727);
assertThat(uid1.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
UidBatteryConsumer uid2 = mStatsRule.getUidBatteryConsumer(APP_UID2);
assertThat(uid2.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(90 * MINUTE_IN_MS);
// Uid2 took 90 out of the total of 110 min of foreground activity
// Uid2 charge = 90 / 110 * 92.0 = 69.0 mAh
assertThat(uid2.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isWithin(PRECISION).of(120.272727);
assertThat(uid2.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
BatteryConsumer appsConsumer = mStatsRule.getAppsBatteryConsumer();
assertThat(appsConsumer.getUsageDurationMillis(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(110 * MINUTE_IN_MS);
assertThat(appsConsumer.getConsumedPower(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isWithin(PRECISION).of(147);
assertThat(appsConsumer.getPowerModel(BatteryConsumer.POWER_COMPONENT_SCREEN))
.isEqualTo(BatteryConsumer.POWER_MODEL_POWER_PROFILE);
}
private void setProcState(int uid, int procState, boolean resumed, long realtimeMs,
long uptimeMs) {
BatteryStatsImpl batteryStats = mStatsRule.getBatteryStats();