[Telemetry] Power metric: subtract quiescent power draw from result

tools/perf/metrics/power.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import time
+
 from metrics import Metric
 from telemetry.value import scalar
 
+
 class PowerMetric(Metric):
   """A metric for measuring power usage."""
 
-  def __init__(self):
+  def __init__(self, browser, quiescent_measurement_time_s=0):
+    """PowerMetric Constructor.
+
+    Args:
+        browser: browser object to use.
+        quiescent_measurement_time_s: time to measure quiescent power,
+            in seconds. 0 means don't measure quiescent power."""
     super(PowerMetric, self).__init__()
-    self._browser = None
+    self._browser = browser
     self._running = False
     self._starting_cpu_stats = None
     self._results = None
+    self._quiescent_power_draw_mwh = 0
+    self._MeasureQuiescentPower(quiescent_measurement_time_s)
 
   def __del__(self):
     # TODO(jeremy): Remove once crbug.com/350841 is fixed.
     # Don't leave power monitoring processes running on the system.
     self._StopInternal()
     parent = super(PowerMetric, self)
     if hasattr(parent, '__del__'):
       parent.__del__()
 
   def _StopInternal(self):
-    """ Stop monitoring power if measurement is running. This function is
+    """Stop monitoring power if measurement is running. This function is
     idempotent."""
     if not self._running:
       return
     self._running = False
     self._results = self._browser.platform.StopMonitoringPower()
     if self._results: # StopMonitoringPower() can return None.
       self._results['cpu_stats'] = (
           _SubtractCpuStats(self._browser.cpu_stats, self._starting_cpu_stats))
 
+  def _MeasureQuiescentPower(self, measurement_time_s):
+    """Measure quiescent power draw for the system."""
+    platform = self._browser.platform
+    if not platform.CanMonitorPower() or \
+        platform.CanMeasurePerApplicationPower() or \
+        not measurement_time_s:
+      return
+
+    platform.StartMonitoringPower(self._browser)
+    time.sleep(measurement_time_s)
+    power_results = platform.StopMonitoringPower()
+    self._quiescent_power_draw_mwh = (
+        power_results.get('energy_consumption_mwh', 0))
+
   def Start(self, _, tab):
     if not tab.browser.platform.CanMonitorPower():
       return
 
     self._results = None
-    self._browser = tab.browser
     self._StopInternal()
 
     # This line invokes top a few times, call before starting power measurement.
     self._starting_cpu_stats = self._browser.cpu_stats
     self._browser.platform.StartMonitoringPower(self._browser)
     self._running = True
 
   def Stop(self, _, tab):
     if not tab.browser.platform.CanMonitorPower():
       return
 
     self._StopInternal()
 
   def AddResults(self, _, results):
     """Add the collected power data into the results object.
 
     This function needs to be robust in the face of differing power data on
     various platforms. Therefore data existence needs to be checked when
     building up the results. Additionally 0 is a valid value for many of the
     metrics here which is why there are plenty of checks for 'is not None'
     below.
     """
     if not self._results:
       return
 
-    energy_consumption_mwh = self._results.get('energy_consumption_mwh')
-    if energy_consumption_mwh is not None:
+    application_energy_consumption_mwh = (
+        self._results.get('application_energy_consumption_mwh'))
+    total_energy_consumption_mwh = self._results.get('energy_consumption_mwh')
+
+    if not application_energy_consumption_mwh and total_energy_consumption_mwh:
+      application_energy_consumption_mwh = max(
+          total_energy_consumption_mwh - self._quiescent_power_draw_mwh, 0)
+
+    if total_energy_consumption_mwh is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'energy_consumption_mwh', 'mWh',
-          energy_consumption_mwh))
+          total_energy_consumption_mwh))
+
+    if application_energy_consumption_mwh is not None:
+      results.AddValue(scalar.ScalarValue(
+          results.current_page, 'application_energy_consumption_mwh', 'mWh',
+          application_energy_consumption_mwh))
 
     component_utilization = self._results.get('component_utilization', {})
     # GPU Frequency.
     gpu_power = component_utilization.get('gpu', {})
     gpu_freq_hz = gpu_power.get('average_frequency_hz')
     if gpu_freq_hz is not None:
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'gpu_average_frequency_hz', 'hz', gpu_freq_hz,
           important=False))
 
@@ skipping 31 matching lines @@
     if (not cpu_stats[process_type]) or (not start_cpu_stats[process_type]):
       continue
     # Skip if IdleWakeupCount is not present.
     if (('IdleWakeupCount' not in cpu_stats[process_type]) or
         ('IdleWakeupCount' not in start_cpu_stats[process_type])):
       continue
     idle_wakeup_delta = (cpu_stats[process_type]['IdleWakeupCount'] -
                         start_cpu_stats[process_type]['IdleWakeupCount'])
     cpu_delta[process_type] = idle_wakeup_delta
   return cpu_delta