[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."""
     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."""
+    # TODO(jeremy): This only makes sense for systems where we can only measure
+    # power globally. Don't do this where power measurement is per-process.
+    if not self._browser.platform.CanMonitorPower() or not measurement_time_s:
+      return
+
+    self._browser.platform.StartMonitoringPower(self._browser)
+    time.sleep(measurement_time_s)
+    power_results = self._browser.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:
+    raw_energy_consumption_mwh = self._results.get('energy_consumption_mwh')
+    if raw_energy_consumption_mwh is not None:
+      energy_consumption_mwh = max(
+          raw_energy_consumption_mwh - self._quiescent_power_draw_mwh, 0)
+
       results.AddValue(scalar.ScalarValue(
           results.current_page, 'energy_consumption_mwh', 'mWh',
           energy_consumption_mwh))
 
+      results.AddValue(scalar.ScalarValue(

[tonyg, 2014/06/26 16:19:04]

WDYT about just reporting two things:

energy_consumption_mwh: Remains unchanged and reports full system energy
consumption (we should document this in the API, as some of the providers I
think are trying to report just chrome here).
application_energy_consumption_mwh: Add this new metric which aims to estimate
just the target application (Chrome's) energy consumption. Some providers may
pass this directly in the platform API. The logic in this metric would be to
compute it if it is not given directly.

+          results.current_page, 'raw_energy_consumption_mwh', 'mWh',
+          raw_energy_consumption_mwh))
+
+      results.AddValue(scalar.ScalarValue(
+          results.current_page, 'quiescent_energy_consumption_mwh', 'mWh',
+          self._quiescent_power_draw_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))
 
     # Add idle wakeup numbers for all processes.
@@ skipping 30 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