Update CPU Monitor to report CPU frequency and battery level.

webrtc/examples/androidapp/src/org/appspot/apprtc/CpuMonitor.java

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 package org.appspot.apprtc;
 
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.BatteryManager;
+import android.os.Environment;
+import android.os.SystemClock;
 import android.util.Log;
 
 import java.io.BufferedReader;
+import java.io.File;
 import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
 import java.io.FileReader;
 import java.io.IOException;
-import java.util.InputMismatchException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
 import java.util.Scanner;
 
+import org.appspot.apprtc.util.LooperExecutor;
+
 /**
  * Simple CPU monitor.  The caller creates a CpuMonitor object which can then
  * be used via sampleCpuUtilization() to collect the percentual use of the
  * cumulative CPU capacity for all CPUs running at their nominal frequency.  3
  * values are generated: (1) getCpuCurrent() returns the use since the last
  * sampleCpuUtilization(), (2) getCpuAvg3() returns the use since 3 prior
  * calls, and (3) getCpuAvgAll() returns the use over all SAMPLE_SAVE_NUMBER
  * calls.
  *
  * <p>CPUs in Android are often "offline", and while this of course means 0 Hz
@@ skipping 23 matching lines @@
  * Queue<Integer> to avoid copying overhead.
  *
  * <p>Known problems:
  *   1. Nexus 7 devices running Kitkat have a kernel which often output an
  *      incorrect 'idle' field in /proc/stat.  The value is close to twice the
  *      correct value, and then returns to back to correct reading.  Both when
  *      jumping up and back down we might create faulty CPU load readings.
  */
 
 class CpuMonitor {
-  private static final int SAMPLE_SAVE_NUMBER = 10;  // Assumed to be >= 3.
-  private int[] percentVec = new int[SAMPLE_SAVE_NUMBER];
-  private int sum3 = 0;
-  private int sum10 = 0;
   private static final String TAG = "CpuMonitor";
-  private long[] cpuFreq;
+  private static final String DUMP_FILE = "cpu_log.txt";
+  private static final int CPU_STAT_SAMPLE_PERIOD = 2000;
+  private static final int CPU_STAT_LOG_PERIOD = 6000;
+
+  private final Context appContext;
+  private LooperExecutor executor;
+  private long lastStatLogTimeMs;
+  private int iterations;
+  private double currentUserCpuUsage;
+  private double currentSystemCpuUsage;
+  private double currentTotalCpuUsage;
+  private double currentFrequencyScale = -1;
+  private double sumUserCpuUsage;
+  private double sumSystemCpuUsage;
+  private double sumFrequencyScale;
+  private double sumTotalCpuUsage;
+  private long[] cpuFreqMax;
   private int cpusPresent;
-  private double lastPercentFreq = -1;
-  private int cpuCurrent;
-  private int cpuAvg3;
-  private int cpuAvgAll;
+  private int actualCpusPresent;
   private boolean initialized = false;
   private String[] maxPath;
   private String[] curPath;
-  ProcStat lastProcStat;
+  private double[] curFreqScales;
+  private ProcStat lastProcStat;
+
+  private static boolean dumpEnabled = false;
+  private static FileOutputStream fileWriter;
 
   private class ProcStat {
-    final long runTime;
+    final long userTime;
+    final long systemTime;
     final long idleTime;
 
-    ProcStat(long aRunTime, long aIdleTime) {
-      runTime = aRunTime;
-      idleTime = aIdleTime;
+    ProcStat(long userTime, long systemTime, long idleTime) {
+      this.userTime = userTime;
+      this.systemTime = systemTime;
+      this.idleTime = idleTime;
     }
   }
 
+  public CpuMonitor(Context context) {
+    Log.d(TAG, "CpuMonitor ctor.");
+    appContext = context.getApplicationContext();
+    lastStatLogTimeMs = 0;
+
+    executor = new LooperExecutor();
+    executor.requestStart();
+    scheduleCpuUtilizationTask();
+  }
+
+  public void release() {
+    if (executor != null) {
+      Log.d(TAG, "release");
+      executor.cancelScheduledTasks();
+      executor.requestStop();
+      executor = null;
+    }
+  }
+
+  public void pause() {
+    if (executor != null) {
+      Log.d(TAG, "pause");
+      executor.cancelScheduledTasks();
+    }
+  }
+
+  public void resume() {
+    if (executor != null) {
+      Log.d(TAG, "resume");
+      resetStat();
+      scheduleCpuUtilizationTask();
+    }
+  }
+
+  public synchronized int getCpuUsageCurrent() {
+    return doubleToPercent(currentTotalCpuUsage);
+  }
+
+  public synchronized int getCpuUsageAverage() {
+    return sumDoubleToPercent(sumTotalCpuUsage, iterations);
+  }
+
+  public synchronized int getCpuFrequencyScaleCurrent() {
+    return doubleToPercent(currentFrequencyScale);
+  }
+
+  private void scheduleCpuUtilizationTask() {
+    executor.scheduleAtFixedRate(new Runnable() {
+      @Override
+      public void run() {
+        logCpuUtilization();
+      }
+    }, CPU_STAT_SAMPLE_PERIOD);
+  }
+
+  private void checkDump(String statString) {
+    if (!dumpEnabled) {
+      return;
+    }
+    if (fileWriter == null) {
+      Log.d(TAG, "Start log dump");
+      String fileName = Environment.getExternalStorageDirectory().getAbsolutePath()
+          + File.separator + DUMP_FILE;
+      try {
+        fileWriter = new FileOutputStream(fileName, false /* append */);
+      } catch (FileNotFoundException e) {
+        Log.e(TAG, "Can not open file.", e);
+        dumpEnabled = false;
+        return;
+      }
+    }
+
+    Date date = Calendar.getInstance().getTime();
+    SimpleDateFormat df = new SimpleDateFormat("MM-dd HH:mm:ss.SSS");
+    String msg = df.format(date) + " " + TAG + ":" + statString + "\n";
+    try {
+      fileWriter.write(msg.getBytes());
+    } catch (IOException e) {
+      Log.e(TAG, "Can not write to file.", e);
+      dumpEnabled = false;
+    }
+  }
+
+  private void logCpuUtilization() {
+    boolean logStatistics = false;
+    if (SystemClock.elapsedRealtime() - lastStatLogTimeMs >= CPU_STAT_LOG_PERIOD) {
+      lastStatLogTimeMs = SystemClock.elapsedRealtime();
+      logStatistics = true;
+    }
+    boolean cpuMonitorAvailable = sampleCpuUtilization();
+    if (logStatistics && cpuMonitorAvailable) {
+      String statString = getStatString();
+      checkDump(statString);
+      Log.d(TAG, statString);
+      resetStat();
+    }
+  }
+
   private void init() {
     try {
       FileReader fin = new FileReader("/sys/devices/system/cpu/present");
       try {
-        BufferedReader rdr = new BufferedReader(fin);
-        Scanner scanner = new Scanner(rdr).useDelimiter("[-\n]");
+        BufferedReader reader = new BufferedReader(fin);
+        Scanner scanner = new Scanner(reader).useDelimiter("[-\n]");
         scanner.nextInt();  // Skip leading number 0.
         cpusPresent = 1 + scanner.nextInt();
         scanner.close();
       } catch (Exception e) {
         Log.e(TAG, "Cannot do CPU stats due to /sys/devices/system/cpu/present parsing problem");
       } finally {
         fin.close();
       }
     } catch (FileNotFoundException e) {
       Log.e(TAG, "Cannot do CPU stats since /sys/devices/system/cpu/present is missing");
     } catch (IOException e) {
       Log.e(TAG, "Error closing file");
     }
 
-    cpuFreq = new long [cpusPresent];
-    maxPath = new String [cpusPresent];
-    curPath = new String [cpusPresent];
+    cpuFreqMax = new long[cpusPresent];
+    maxPath = new String[cpusPresent];
+    curPath = new String[cpusPresent];
+    curFreqScales = new double[cpusPresent];
     for (int i = 0; i < cpusPresent; i++) {
-      cpuFreq[i] = 0;  // Frequency "not yet determined".
+      cpuFreqMax[i] = 0;  // Frequency "not yet determined".
+      curFreqScales[i] = 0;
       maxPath[i] = "/sys/devices/system/cpu/cpu" + i + "/cpufreq/cpuinfo_max_freq";
       curPath[i] = "/sys/devices/system/cpu/cpu" + i + "/cpufreq/scaling_cur_freq";
     }
 
-    lastProcStat = new ProcStat(0, 0);
+    lastProcStat = new ProcStat(0, 0, 0);
+    resetStat();
 
     initialized = true;
   }
 
+  private synchronized void resetStat() {
+    sumUserCpuUsage = 0;
+    sumSystemCpuUsage = 0;
+    sumFrequencyScale = 0;
+    sumTotalCpuUsage = 0;
+    iterations = 0;
+  }
+
+  private int getBatteryLevel() {
+    // Use sticky broadcast with null receiver to read battery level once only.
+    Intent intent = appContext.registerReceiver(
+        null /* receiver */, new IntentFilter(Intent.ACTION_BATTERY_CHANGED));
+
+    int batteryLevel = 0;
+    int batteryScale = intent.getIntExtra(BatteryManager.EXTRA_SCALE, 100);
+    if (batteryScale > 0) {
+      batteryLevel = (int) (
+          100f * intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0) / batteryScale);
+    }
+    return batteryLevel;
+  }
+
   /**
    * Re-measure CPU use.  Call this method at an interval of around 1/s.
    * This method returns true on success.  The fields
    * cpuCurrent, cpuAvg3, and cpuAvgAll are updated on success, and represents:
    * cpuCurrent: The CPU use since the last sampleCpuUtilization call.
    * cpuAvg3: The average CPU over the last 3 calls.
    * cpuAvgAll: The average CPU over the last SAMPLE_SAVE_NUMBER calls.
    */
-  public boolean sampleCpuUtilization() {
+  private synchronized boolean sampleCpuUtilization() {
     long lastSeenMaxFreq = 0;
-    long cpufreqCurSum = 0;
-    long cpufreqMaxSum = 0;
+    long cpuFreqCurSum = 0;
+    long cpuFreqMaxSum = 0;
 
     if (!initialized) {
       init();
     }
+    if (cpusPresent == 0) {
+      return false;
+    }
 
+    actualCpusPresent = 0;
     for (int i = 0; i < cpusPresent; i++) {
       /*
        * For each CPU, attempt to first read its max frequency, then its
        * current frequency.  Once as the max frequency for a CPU is found,
-       * save it in cpuFreq[].
+       * save it in cpuFreqMax[].
        */
 
-      if (cpuFreq[i] == 0) {
+      curFreqScales[i] = 0;
+      if (cpuFreqMax[i] == 0) {
         // We have never found this CPU's max frequency.  Attempt to read it.
         long cpufreqMax = readFreqFromFile(maxPath[i]);
         if (cpufreqMax > 0) {
           lastSeenMaxFreq = cpufreqMax;
-          cpuFreq[i] = cpufreqMax;
+          cpuFreqMax[i] = cpufreqMax;
           maxPath[i] = null;  // Kill path to free its memory.
         }
       } else {
-        lastSeenMaxFreq = cpuFreq[i];  // A valid, previously read value.
+        lastSeenMaxFreq = cpuFreqMax[i];  // A valid, previously read value.
       }
 
-      long cpufreqCur = readFreqFromFile(curPath[i]);
-      cpufreqCurSum += cpufreqCur;
+      long cpuFreqCur = readFreqFromFile(curPath[i]);
+      if (cpuFreqCur == 0 && lastSeenMaxFreq == 0) {
+        // No current frequency information for this CPU core - ignore it.
+        continue;
+      }
+      if (cpuFreqCur > 0) {
+        actualCpusPresent++;
+      }
+      cpuFreqCurSum += cpuFreqCur;
 
       /* Here, lastSeenMaxFreq might come from
        * 1. cpuFreq[i], or
        * 2. a previous iteration, or
        * 3. a newly read value, or
        * 4. hypothetically from the pre-loop dummy.
        */
-      cpufreqMaxSum += lastSeenMaxFreq;
+      cpuFreqMaxSum += lastSeenMaxFreq;
+      if (lastSeenMaxFreq > 0) {
+        curFreqScales[i] = (double) cpuFreqCur / lastSeenMaxFreq;
+      }
     }
 
-    if (cpufreqMaxSum == 0) {
-      Log.e(TAG, "Could not read max frequency for any CPU");
+    if (cpuFreqCurSum == 0 || cpuFreqMaxSum == 0) {
+      Log.e(TAG, "Could not read max or current frequency for any CPU");
       return false;
     }
 
     /*
      * Since the cycle counts are for the period between the last invocation
      * and this present one, we average the percentual CPU frequencies between
      * now and the beginning of the measurement period.  This is significantly
      * incorrect only if the frequencies have peeked or dropped in between the
      * invocations.
      */
-    double newPercentFreq = 100.0 * cpufreqCurSum / cpufreqMaxSum;
-    double percentFreq;
-    if (lastPercentFreq > 0) {
-      percentFreq = (lastPercentFreq + newPercentFreq) * 0.5;
+    double newFrequencyScale = (double) cpuFreqCurSum / cpuFreqMaxSum;
+    double frequencyScale;
+    if (currentFrequencyScale > 0) {
+      frequencyScale = (currentFrequencyScale + newFrequencyScale) * 0.5;
     } else {
-      percentFreq = newPercentFreq;
+      frequencyScale = newFrequencyScale;
     }
-    lastPercentFreq = newPercentFreq;
 
-    ProcStat procStat = readIdleAndRunTime();
+    ProcStat procStat = readProcStat();
     if (procStat == null) {
       return false;
     }
 
-    long diffRunTime = procStat.runTime - lastProcStat.runTime;
+    long diffUserTime = procStat.userTime - lastProcStat.userTime;
+    long diffSystemTime = procStat.systemTime - lastProcStat.systemTime;
     long diffIdleTime = procStat.idleTime - lastProcStat.idleTime;
+    long allTime = diffUserTime + diffSystemTime + diffIdleTime;
 
+    if (frequencyScale == 0 || allTime == 0) {
+      return false;
+    }
+
+    // Update statistics.
+    currentFrequencyScale = frequencyScale;
+    sumFrequencyScale += frequencyScale;
+
+    currentUserCpuUsage = (double) diffUserTime / allTime;
+    sumUserCpuUsage += currentUserCpuUsage;
+
+    currentSystemCpuUsage = (double) diffSystemTime / allTime;
+    sumSystemCpuUsage += currentSystemCpuUsage;
+
+    currentTotalCpuUsage = (currentUserCpuUsage + currentSystemCpuUsage) * currentFrequencyScale;
+    sumTotalCpuUsage += currentTotalCpuUsage;
+
+    iterations++;
     // Save new measurements for next round's deltas.
     lastProcStat = procStat;
 
-    long allTime = diffRunTime + diffIdleTime;
-    int percent = allTime == 0 ? 0 : (int) Math.round(percentFreq * diffRunTime / allTime);
-    percent = Math.max(0, Math.min(percent, 100));
-
-    // Subtract old relevant measurement, add newest.
-    sum3 += percent - percentVec[2];
-    // Subtract oldest measurement, add newest.
-    sum10 += percent - percentVec[SAMPLE_SAVE_NUMBER - 1];
-
-    // Rotate saved percent values, save new measurement in vacated spot.
-    for (int i = SAMPLE_SAVE_NUMBER - 1; i > 0; i--) {
-      percentVec[i] = percentVec[i - 1];
-    }
-    percentVec[0] = percent;
-
-    cpuCurrent = percent;
-    cpuAvg3 = sum3 / 3;
-    cpuAvgAll = sum10 / SAMPLE_SAVE_NUMBER;
-
     return true;
   }
 
-  public int getCpuCurrent() {
-    return cpuCurrent;
+  private int doubleToPercent(double d) {
+    return (int) (d * 100 + 0.5);
   }
 
-  public int getCpuAvg3() {
-    return cpuAvg3;
+  private int sumDoubleToPercent(double d, int iterations) {
+    if (iterations > 0) {
+      return (int) (d * 100.0 / (double) iterations + 0.5);
+    } else {
+      return 0;
+    }
   }
 
-  public int getCpuAvgAll() {
-    return cpuAvgAll;
+  private String getStatString() {
+    StringBuilder stat = new StringBuilder();
+    stat.append("CPU User: ")
+        .append(doubleToPercent(currentUserCpuUsage)).append("/")
+        .append(sumDoubleToPercent(sumUserCpuUsage, iterations)).append(" (")
+        .append(doubleToPercent(currentUserCpuUsage * currentFrequencyScale)).append(")")
+        .append(". System: ")
+        .append(doubleToPercent(currentSystemCpuUsage)).append("/")
+        .append(sumDoubleToPercent(sumSystemCpuUsage, iterations)).append(" (")
+        .append(doubleToPercent(currentSystemCpuUsage * currentFrequencyScale)).append(")")
+        .append(". CPU freq %: ")
+        .append(doubleToPercent(currentFrequencyScale)).append("/")
+        .append(sumDoubleToPercent(sumFrequencyScale, iterations))
+        .append(". Total CPU usage: ")
+        .append(doubleToPercent(currentTotalCpuUsage)).append("/")
+        .append(sumDoubleToPercent(sumTotalCpuUsage, iterations))
+        .append(". Cores: ")
+        .append(actualCpusPresent);
+    stat.append("( ");
+    for (int i = 0; i < cpusPresent; i++) {
+      stat.append(doubleToPercent(curFreqScales[i])).append(" ");
+    }
+    stat.append("). Battery %: ")
+        .append(getBatteryLevel());
+    return stat.toString();
   }
 
   /**
    * Read a single integer value from the named file.  Return the read value
    * or if an error occurs return 0.
    */
   private long readFreqFromFile(String fileName) {
     long number = 0;
     try {
       FileReader fin = new FileReader(fileName);
@@ skipping 12 matching lines @@
     } catch (IOException e) {
       Log.e(TAG, "Error closing file");
     }
     return number;
   }
 
   /*
    * Read the current utilization of all CPUs using the cumulative first line
    * of /proc/stat.
    */
-  private ProcStat readIdleAndRunTime() {
-    long runTime = 0;
+  private ProcStat readProcStat() {
+    long userTime = 0;
+    long systemTime = 0;
     long idleTime = 0;
     try {
       FileReader fin = new FileReader("/proc/stat");
       try {
         BufferedReader rdr = new BufferedReader(fin);
         Scanner scanner = new Scanner(rdr);
         scanner.next();
-        long user = scanner.nextLong();
+        userTime = scanner.nextLong();
         long nice = scanner.nextLong();
-        long sys = scanner.nextLong();
-        runTime = user + nice + sys;
+        userTime += nice;
+        systemTime = scanner.nextLong();
         idleTime = scanner.nextLong();
+        long ioWaitTime = scanner.nextLong();
+        userTime += ioWaitTime;
         scanner.close();
       } catch (Exception e) {
         Log.e(TAG, "Problems parsing /proc/stat");
         return null;
       } finally {
         fin.close();
       }
     } catch (FileNotFoundException e) {
       Log.e(TAG, "Cannot open /proc/stat for reading");
       return null;
     } catch (IOException e) {
       Log.e(TAG, "Problems reading /proc/stat");
       return null;
     }
-    return new ProcStat(runTime, idleTime);
+    return new ProcStat(userTime, systemTime, idleTime);
   }
 }