| /* |
| * Copyright (C) 2022 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.tare; |
| |
| import static android.text.format.DateUtils.HOUR_IN_MILLIS; |
| |
| import static com.android.server.tare.EconomicPolicy.TYPE_ACTION; |
| import static com.android.server.tare.EconomicPolicy.TYPE_REGULATION; |
| import static com.android.server.tare.EconomicPolicy.TYPE_REWARD; |
| import static com.android.server.tare.EconomicPolicy.getEventType; |
| import static com.android.server.tare.TareUtils.cakeToString; |
| |
| import android.annotation.NonNull; |
| import android.os.BatteryManagerInternal; |
| import android.os.RemoteException; |
| import android.util.IndentingPrintWriter; |
| import android.util.Log; |
| |
| import com.android.internal.annotations.VisibleForTesting; |
| import com.android.internal.app.IBatteryStats; |
| import com.android.server.LocalServices; |
| import com.android.server.am.BatteryStatsService; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| |
| /** |
| * Responsible for maintaining statistics and analysis of TARE's performance. |
| */ |
| public class Analyst { |
| private static final String TAG = "TARE-" + Analyst.class.getSimpleName(); |
| private static final boolean DEBUG = InternalResourceService.DEBUG |
| || Log.isLoggable(TAG, Log.DEBUG); |
| |
| private static final int NUM_PERIODS_TO_RETAIN = 8; |
| @VisibleForTesting |
| static final long MIN_REPORT_DURATION_FOR_RESET = 24 * HOUR_IN_MILLIS; |
| |
| static final class Report { |
| /** How much the battery was discharged over the tracked period. */ |
| public int cumulativeBatteryDischarge = 0; |
| public int currentBatteryLevel = 0; |
| /** |
| * Profit from performing actions. This excludes special circumstances where we charge the |
| * app |
| * less than the action's CTP. |
| */ |
| public long cumulativeProfit = 0; |
| public int numProfitableActions = 0; |
| /** |
| * Losses from performing actions for special circumstances (eg. for a TOP app) where we |
| * charge |
| * the app less than the action's CTP. |
| */ |
| public long cumulativeLoss = 0; |
| public int numUnprofitableActions = 0; |
| /** |
| * The total number of rewards given to apps over this period. |
| */ |
| public long cumulativeRewards = 0; |
| public int numRewards = 0; |
| /** |
| * Regulations that increased an app's balance. |
| */ |
| public long cumulativePositiveRegulations = 0; |
| public int numPositiveRegulations = 0; |
| /** |
| * Regulations that decreased an app's balance. |
| */ |
| public long cumulativeNegativeRegulations = 0; |
| public int numNegativeRegulations = 0; |
| |
| /** |
| * The approximate amount of time the screen has been off while on battery while this |
| * report has been active. |
| */ |
| public long screenOffDurationMs = 0; |
| /** |
| * The approximate amount of battery discharge while this report has been active. |
| */ |
| public long screenOffDischargeMah = 0; |
| /** The offset used to get the delta when polling the screen off time from BatteryStats. */ |
| private long bsScreenOffRealtimeBase = 0; |
| /** |
| * The offset used to get the delta when polling the screen off discharge from BatteryStats. |
| */ |
| private long bsScreenOffDischargeMahBase = 0; |
| |
| private void clear() { |
| cumulativeBatteryDischarge = 0; |
| currentBatteryLevel = 0; |
| cumulativeProfit = 0; |
| numProfitableActions = 0; |
| cumulativeLoss = 0; |
| numUnprofitableActions = 0; |
| cumulativeRewards = 0; |
| numRewards = 0; |
| cumulativePositiveRegulations = 0; |
| numPositiveRegulations = 0; |
| cumulativeNegativeRegulations = 0; |
| numNegativeRegulations = 0; |
| screenOffDurationMs = 0; |
| screenOffDischargeMah = 0; |
| bsScreenOffRealtimeBase = 0; |
| bsScreenOffDischargeMahBase = 0; |
| } |
| } |
| |
| private final IBatteryStats mIBatteryStats; |
| |
| private int mPeriodIndex = 0; |
| /** How much the battery was discharged over the tracked period. */ |
| private final Report[] mReports = new Report[NUM_PERIODS_TO_RETAIN]; |
| |
| Analyst() { |
| this(BatteryStatsService.getService()); |
| } |
| |
| @VisibleForTesting Analyst(IBatteryStats iBatteryStats) { |
| mIBatteryStats = iBatteryStats; |
| } |
| |
| /** Returns the list of most recent reports, with the oldest report first. */ |
| @NonNull |
| List<Report> getReports() { |
| final List<Report> list = new ArrayList<>(NUM_PERIODS_TO_RETAIN); |
| for (int i = 1; i <= NUM_PERIODS_TO_RETAIN; ++i) { |
| final int idx = (mPeriodIndex + i) % NUM_PERIODS_TO_RETAIN; |
| final Report report = mReports[idx]; |
| if (report != null) { |
| list.add(report); |
| } |
| } |
| return list; |
| } |
| |
| long getBatteryScreenOffDischargeMah() { |
| long discharge = 0; |
| for (Report report : mReports) { |
| if (report == null) { |
| continue; |
| } |
| discharge += report.screenOffDischargeMah; |
| } |
| return discharge; |
| } |
| |
| long getBatteryScreenOffDurationMs() { |
| long duration = 0; |
| for (Report report : mReports) { |
| if (report == null) { |
| continue; |
| } |
| duration += report.screenOffDurationMs; |
| } |
| return duration; |
| } |
| |
| /** |
| * Tracks the given reports instead of whatever is currently saved. Reports should be ordered |
| * oldest to most recent. |
| */ |
| void loadReports(@NonNull List<Report> reports) { |
| final int numReports = reports.size(); |
| mPeriodIndex = Math.max(0, Math.min(NUM_PERIODS_TO_RETAIN, numReports) - 1); |
| for (int i = 0; i < NUM_PERIODS_TO_RETAIN; ++i) { |
| if (i < numReports) { |
| mReports[i] = reports.get(i); |
| } else { |
| mReports[i] = null; |
| } |
| } |
| final Report latest = mReports[mPeriodIndex]; |
| if (latest != null) { |
| latest.bsScreenOffRealtimeBase = getLatestBatteryScreenOffRealtimeMs(); |
| latest.bsScreenOffDischargeMahBase = getLatestScreenOffDischargeMah(); |
| } |
| } |
| |
| void noteBatteryLevelChange(int newBatteryLevel) { |
| final boolean deviceDischargedEnough = mReports[mPeriodIndex] != null |
| && newBatteryLevel >= 90 |
| // Battery level is increasing, so device is charging. |
| && mReports[mPeriodIndex].currentBatteryLevel < newBatteryLevel |
| && mReports[mPeriodIndex].cumulativeBatteryDischarge >= 25; |
| final boolean reportLongEnough = mReports[mPeriodIndex] != null |
| // Battery level is increasing, so device is charging. |
| && mReports[mPeriodIndex].currentBatteryLevel < newBatteryLevel |
| && mReports[mPeriodIndex].screenOffDurationMs >= MIN_REPORT_DURATION_FOR_RESET; |
| final boolean shouldStartNewReport = deviceDischargedEnough || reportLongEnough; |
| if (shouldStartNewReport) { |
| mPeriodIndex = (mPeriodIndex + 1) % NUM_PERIODS_TO_RETAIN; |
| if (mReports[mPeriodIndex] != null) { |
| final Report report = mReports[mPeriodIndex]; |
| report.clear(); |
| report.currentBatteryLevel = newBatteryLevel; |
| report.bsScreenOffRealtimeBase = getLatestBatteryScreenOffRealtimeMs(); |
| report.bsScreenOffDischargeMahBase = getLatestScreenOffDischargeMah(); |
| return; |
| } |
| } |
| |
| if (mReports[mPeriodIndex] == null) { |
| Report report = initializeReport(); |
| mReports[mPeriodIndex] = report; |
| report.currentBatteryLevel = newBatteryLevel; |
| return; |
| } |
| |
| final Report report = mReports[mPeriodIndex]; |
| if (newBatteryLevel < report.currentBatteryLevel) { |
| report.cumulativeBatteryDischarge += (report.currentBatteryLevel - newBatteryLevel); |
| |
| final long latestScreenOffRealtime = getLatestBatteryScreenOffRealtimeMs(); |
| final long latestScreenOffDischargeMah = getLatestScreenOffDischargeMah(); |
| if (report.bsScreenOffRealtimeBase > latestScreenOffRealtime) { |
| // BatteryStats reset |
| report.bsScreenOffRealtimeBase = 0; |
| report.bsScreenOffDischargeMahBase = 0; |
| } |
| report.screenOffDurationMs += |
| (latestScreenOffRealtime - report.bsScreenOffRealtimeBase); |
| report.screenOffDischargeMah += |
| (latestScreenOffDischargeMah - report.bsScreenOffDischargeMahBase); |
| report.bsScreenOffRealtimeBase = latestScreenOffRealtime; |
| report.bsScreenOffDischargeMahBase = latestScreenOffDischargeMah; |
| } |
| report.currentBatteryLevel = newBatteryLevel; |
| } |
| |
| void noteTransaction(@NonNull Ledger.Transaction transaction) { |
| if (mReports[mPeriodIndex] == null) { |
| mReports[mPeriodIndex] = initializeReport(); |
| } |
| final Report report = mReports[mPeriodIndex]; |
| switch (getEventType(transaction.eventId)) { |
| case TYPE_ACTION: |
| // For now, assume all instances where price < CTP is a special instance. |
| // TODO: add an explicit signal for special circumstances |
| if (-transaction.delta > transaction.ctp) { |
| report.cumulativeProfit += (-transaction.delta - transaction.ctp); |
| report.numProfitableActions++; |
| } else if (-transaction.delta < transaction.ctp) { |
| report.cumulativeLoss += (transaction.ctp + transaction.delta); |
| report.numUnprofitableActions++; |
| } |
| break; |
| case TYPE_REGULATION: |
| if (transaction.delta > 0) { |
| report.cumulativePositiveRegulations += transaction.delta; |
| report.numPositiveRegulations++; |
| } else if (transaction.delta < 0) { |
| report.cumulativeNegativeRegulations -= transaction.delta; |
| report.numNegativeRegulations++; |
| } |
| break; |
| case TYPE_REWARD: |
| if (transaction.delta != 0) { |
| report.cumulativeRewards += transaction.delta; |
| report.numRewards++; |
| } |
| break; |
| } |
| } |
| |
| void tearDown() { |
| for (int i = 0; i < mReports.length; ++i) { |
| mReports[i] = null; |
| } |
| mPeriodIndex = 0; |
| } |
| |
| private long getLatestBatteryScreenOffRealtimeMs() { |
| try { |
| return mIBatteryStats.computeBatteryScreenOffRealtimeMs(); |
| } catch (RemoteException e) { |
| // Shouldn't happen |
| return 0; |
| } |
| } |
| |
| private long getLatestScreenOffDischargeMah() { |
| try { |
| return mIBatteryStats.getScreenOffDischargeMah(); |
| } catch (RemoteException e) { |
| // Shouldn't happen |
| return 0; |
| } |
| } |
| |
| @NonNull |
| private Report initializeReport() { |
| final Report report = new Report(); |
| report.bsScreenOffRealtimeBase = getLatestBatteryScreenOffRealtimeMs(); |
| report.bsScreenOffDischargeMahBase = getLatestScreenOffDischargeMah(); |
| return report; |
| } |
| |
| @NonNull |
| private String padStringWithSpaces(@NonNull String text, int targetLength) { |
| // Make sure to have at least one space on either side. |
| final int padding = Math.max(2, targetLength - text.length()) >>> 1; |
| return " ".repeat(padding) + text + " ".repeat(padding); |
| } |
| |
| void dump(IndentingPrintWriter pw) { |
| final BatteryManagerInternal bmi = LocalServices.getService(BatteryManagerInternal.class); |
| final long batteryCapacityMah = bmi.getBatteryFullCharge() / 1000; |
| pw.println("Reports:"); |
| pw.increaseIndent(); |
| pw.print(" Total Discharge"); |
| final int statColsLength = 47; |
| pw.print(padStringWithSpaces("Profit (avg/action : avg/discharge)", statColsLength)); |
| pw.print(padStringWithSpaces("Loss (avg/action : avg/discharge)", statColsLength)); |
| pw.print(padStringWithSpaces("Rewards (avg/reward : avg/discharge)", statColsLength)); |
| pw.print(padStringWithSpaces("+Regs (avg/reg : avg/discharge)", statColsLength)); |
| pw.print(padStringWithSpaces("-Regs (avg/reg : avg/discharge)", statColsLength)); |
| pw.print(padStringWithSpaces("Bg drain estimate", statColsLength)); |
| pw.println(); |
| for (int r = 0; r < NUM_PERIODS_TO_RETAIN; ++r) { |
| final int idx = (mPeriodIndex - r + NUM_PERIODS_TO_RETAIN) % NUM_PERIODS_TO_RETAIN; |
| final Report report = mReports[idx]; |
| if (report == null) { |
| continue; |
| } |
| pw.print("t-"); |
| pw.print(r); |
| pw.print(": "); |
| pw.print(padStringWithSpaces(Integer.toString(report.cumulativeBatteryDischarge), 15)); |
| if (report.numProfitableActions > 0) { |
| final String perDischarge = report.cumulativeBatteryDischarge > 0 |
| ? cakeToString(report.cumulativeProfit / report.cumulativeBatteryDischarge) |
| : "N/A"; |
| pw.print(padStringWithSpaces(String.format("%s (%s : %s)", |
| cakeToString(report.cumulativeProfit), |
| cakeToString(report.cumulativeProfit / report.numProfitableActions), |
| perDischarge), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| if (report.numUnprofitableActions > 0) { |
| final String perDischarge = report.cumulativeBatteryDischarge > 0 |
| ? cakeToString(report.cumulativeLoss / report.cumulativeBatteryDischarge) |
| : "N/A"; |
| pw.print(padStringWithSpaces(String.format("%s (%s : %s)", |
| cakeToString(report.cumulativeLoss), |
| cakeToString(report.cumulativeLoss / report.numUnprofitableActions), |
| perDischarge), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| if (report.numRewards > 0) { |
| final String perDischarge = report.cumulativeBatteryDischarge > 0 |
| ? cakeToString(report.cumulativeRewards / report.cumulativeBatteryDischarge) |
| : "N/A"; |
| pw.print(padStringWithSpaces(String.format("%s (%s : %s)", |
| cakeToString(report.cumulativeRewards), |
| cakeToString(report.cumulativeRewards / report.numRewards), |
| perDischarge), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| if (report.numPositiveRegulations > 0) { |
| final String perDischarge = report.cumulativeBatteryDischarge > 0 |
| ? cakeToString( |
| report.cumulativePositiveRegulations / report.cumulativeBatteryDischarge) |
| : "N/A"; |
| pw.print(padStringWithSpaces(String.format("%s (%s : %s)", |
| cakeToString(report.cumulativePositiveRegulations), |
| cakeToString(report.cumulativePositiveRegulations |
| / report.numPositiveRegulations), |
| perDischarge), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| if (report.numNegativeRegulations > 0) { |
| final String perDischarge = report.cumulativeBatteryDischarge > 0 |
| ? cakeToString( |
| report.cumulativeNegativeRegulations / report.cumulativeBatteryDischarge) |
| : "N/A"; |
| pw.print(padStringWithSpaces(String.format("%s (%s : %s)", |
| cakeToString(report.cumulativeNegativeRegulations), |
| cakeToString(report.cumulativeNegativeRegulations |
| / report.numNegativeRegulations), |
| perDischarge), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| if (report.screenOffDurationMs > 0) { |
| pw.print(padStringWithSpaces(String.format("%d mAh (%.2f%%/hr)", |
| report.screenOffDischargeMah, |
| 100.0 * report.screenOffDischargeMah * HOUR_IN_MILLIS |
| / (batteryCapacityMah * report.screenOffDurationMs)), |
| statColsLength)); |
| } else { |
| pw.print(padStringWithSpaces("N/A", statColsLength)); |
| } |
| pw.println(); |
| } |
| pw.decreaseIndent(); |
| } |
| } |
