[telemetry] Add IPPET power monitor.

tools/telemetry/telemetry/core/platform/power_monitor/ippet_power_monitor.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 csv
+import operator
+import os
+import platform
+import re
+import shutil
+import tempfile
+import urllib2
+import zipfile
+
+from telemetry import decorators
+from telemetry.core import util
+from telemetry.core.platform import platform_backend
+from telemetry.core.platform import power_monitor
+from telemetry.util import cloud_storage
+from telemetry.util import path
+from telemetry.util import statistics
+
+try:
+  import win32event  # pylint: disable=F0401
+except ImportError:
+  win32event = None
+
+
+@decorators.Cache
+def IppetPath():
+  # Look for pre-installed IPPET.
+  ippet_path = path.FindInstalledWindowsApplication(os.path.join(
+    'Intel', 'Intel(R) Platform Power Estimation Tool', 'ippet.exe'))
+  if ippet_path:
+    return ippet_path
+
+  # Look for IPPET installed previously by this script.
+  ippet_path = os.path.join(
+      path.GetTelemetryDir(), 'bin', 'win', 'ippet', 'ippet.exe')

[tonyg, 2014/07/24 01:32:03]

support_binaries.FindPath('ippet')?

+  if path.IsExecutable(ippet_path):
+    return ippet_path
+
+  # Install IPPET.

[tonyg, 2014/07/24 01:32:03]

Rock on! You figured it out :)

Can we instead teach platform.CanLaunchApplication/InstallApplication('ippet')
to do this on windows? Similar to the way linux_platform_backend works. That
code'll probably need some cleanup, but I think it'd best best for now. WDYT?

+  zip_path = os.path.join(path.GetTelemetryDir(), 'bin', 'win', 'ippet.zip')
+  cloud_storage.GetIfChanged(zip_path, bucket=cloud_storage.PUBLIC_BUCKET)
+  with zipfile.ZipFile(zip_path, 'r') as zip_file:

[tonyg, 2014/07/24 01:38:28]

I wonder whether support binaries should be made zip aware (perhaps based on
extension)?

+    zip_file.extractall(os.path.dirname(zip_path))
+  os.remove(zip_path)
+
+  if path.IsExecutable(ippet_path):
+    return ippet_path
+
+  return None
+
+
+class IppetPowerMonitor(power_monitor.PowerMonitor):
+  def __init__(self, backend):
+    super(IppetPowerMonitor, self).__init__()
+    self._backend = backend
+    self._ippet_handle = None
+    self._ippet_port = None
+    self._output_dir = None
+
+  def CanMonitorPower(self):
+    if not win32event:
+      return False
+
+    windows_7_or_later = (
+        self._backend.GetOSName() == 'win' and
+        self._backend.GetOSVersionName() >= platform_backend.WIN7)
+    if not windows_7_or_later:
+      return False
+
+    # This check works on Windows only.
+    family, model = map(int, re.match('.+ Family ([0-9]+) Model ([0-9]+)',
+                        platform.processor()).groups())
+    # Model numbers from:
+    # https://software.intel.com/en-us/articles/intel-architecture-and- \
+    # processor-identification-with-cpuid-model-and-family-numbers
+    # http://www.speedtraq.com
+    sandy_bridge_or_later = ('Intel' in platform.processor() and family == 6 and
+                             (model in (0x2A, 0x2D) or model >= 0x30))
+    if not sandy_bridge_or_later:
+      return False
+
+    if not IppetPath():
+      return False
+
+    return True
+
+  def CanMeasurePerApplicationPower(self):
+    return self.CanMonitorPower()
+
+  def StartMonitoringPower(self, browser):
+    assert not self._ippet_handle, 'Called StartMonitoringPower() twice.'
+    self._output_dir = tempfile.mkdtemp()
+    self._ippet_port = util.GetUnreservedAvailableLocalPort()
+    parameters = ['-log_dir', self._output_dir,
+                  '-web_port', str(self._ippet_port),
+                  '-zip', 'n', '-all_processes', '-l', '0']
+    self._ippet_handle = self._backend.LaunchApplication(
+        IppetPath(), parameters, elevate_privilege=True)
+
+    def IppetServerIsUp():
+      try:
+        urllib2.urlopen('http://127.0.0.1:%d/ippet' % self._ippet_port)
+      except urllib2.URLError:
+        return False
+      return True
+    util.WaitFor(IppetServerIsUp, timeout=5)
+
+  def StopMonitoringPower(self):
+    assert self._ippet_handle, (
+        'Called StopMonitoringPower() before StartMonitoringPower().')
+    # Stop IPPET.
+    ippet_quit_url = 'http://127.0.0.1:%d/ippet?cmd=quit' % self._ippet_port
+    urllib2.urlopen(ippet_quit_url).read()
+    win32event.WaitForSingleObject(self._ippet_handle, 5000)
+    self._ippet_handle = None
+    self._ippet_port = None
+
+    # Read IPPET's log file.
+    log_file = os.path.join(self._output_dir, 'ippet_log_processes.xls')
+    with open(log_file, 'r') as f:
+      reader = csv.DictReader(f, dialect='excel-tab')
+      data = list(reader)[1:]  # The initial iteration only reports temperature.
+    shutil.rmtree(self._output_dir)
+    self._output_dir = None
+
+    def get(*args, **kwargs):
+      """Pull all iterations of a field from the IPPET data as a list.
+
+      Args:
+        args: A list representing the field name.
+        mult: A cosntant to multiply the field's value by, for unit conversions.
+        default: The default value if the field is not found in the iteration.
+
+      Returns:
+        A list containing the field's value across all iterations.
+      """
+      key = '\\\\.\\' + '\\'.join(args)
+      def value(line):
+        if key in line:
+          return line[key]
+        elif 'default' in kwargs:
+          return kwargs['default']
+        else:
+          raise KeyError('Key "%s" not found in data and '
+                         'no default was given.' % key)
+      return [float(value(line)) * kwargs.get('mult', 1) for line in data]
+
+    result = {
+        'identifier': 'ippet',
+        'power_samples_mw': get('Power(_Total)', 'Package W', mult=1000),
+        'energy_consumption_mwh':
+            sum(map(operator.mul,
+                    get('Power(_Total)', 'Package W', mult=1000),
+                    get('sys', 'Interval(secs)', mult=1./3600.))),
+        'component_utilization': {
+            'whole_package': {
+                'average_temperature_c':
+                    statistics.ArithmeticMean(get(
+                        'Temperature(Package)', 'Current C')),
+            },
+            'cpu': {
+                'power_samples_mw': get('Power(_Total)', 'CPU W', mult=1000),
+                'energy_consumption_mwh':
+                    sum(map(operator.mul,
+                            get('Power(_Total)', 'CPU W', mult=1000),
+                            get('sys', 'Interval(secs)', mult=1./3600.))),
+            },
+            'disk': {
+                'power_samples_mw': get('Power(_Total)', 'Disk W', mult=1000),
+                'energy_consumption_mwh':
+                    sum(map(operator.mul,
+                            get('Power(_Total)', 'Disk W', mult=1000),
+                            get('sys', 'Interval(secs)', mult=1./3600.))),
+            },
+            'gpu': {
+                'power_samples_mw': get('Power(_Total)', 'GPU W', mult=1000),
+                'energy_consumption_mwh':
+                    sum(map(operator.mul,
+                            get('Power(_Total)', 'GPU W', mult=1000),
+                            get('sys', 'Interval(secs)', mult=1./3600.))),
+            },
+        },
+    }
+
+    # Find Chrome processes in data. Note that this won't work if there are
+    # extra Chrome processes lying around.
+    chrome_keys = set()
+    for iteration in data:
+      for key in iteration.iterkeys():
+        parts = key.split('\\')
+        if (len(parts) >= 4 and
+            re.match(r'Process\(Google Chrome [0-9]+\)', parts[3])):

[tonyg, 2014/07/24 01:38:28]

I don't think we're supposed to do it this way. There's a pid in the browser
backend that this class gets. Then there's something like a GetChildProcesses
method in platform. It should give us all the pids we're interested in.

[dtu, 2014/07/24 23:13:15]

This class gets a PlatformBackend in its constructor and a Browser in
StartMonitoringPower, but never a BrowserBackend. So the pid isn't visible here.

+          chrome_keys.add(parts[3])
+    # Add Chrome process power usage to result.
+    # Note that this is only an estimate of Chrome's CPU power usage.
+    if chrome_keys:
+      per_process_power_usage = [
+          get(key, 'CPU Power W', default=0, mult=1000) for key in chrome_keys]
+      result['application_energy_consumption_mwh'] = (
+          sum(map(operator.mul,
+                  map(sum, zip(*per_process_power_usage)),
+                  get('sys', 'Interval(secs)', mult=1./3600.))))
+
+    return result