[Android] Move perf utilities into devil.

BUG=476719

Review URL: https://codereview.chromium.org/1332603002

Cr-Commit-Position: refs/heads/master@{#347808}

build/android/devil/android/perf/__init__.py

+# Copyright 2015 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.

build/android/devil/android/perf/cache_control.py

+# Copyright 2013 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.
+
+
+class CacheControl(object):
+  _DROP_CACHES = '/proc/sys/vm/drop_caches'
+
+  def __init__(self, device):
+    self._device = device
+
+  def DropRamCaches(self):
+    """Drops the filesystem ram caches for performance testing."""
+    self._device.RunShellCommand('sync', as_root=True)
+    self._device.WriteFile(CacheControl._DROP_CACHES, '3', as_root=True)
+

build/android/devil/android/perf/perf_control.py

+# Copyright 2013 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 atexit
+import logging
+
+from devil.android import device_errors
+
+
+class PerfControl(object):
+  """Provides methods for setting the performance mode of a device."""
+  _CPU_PATH = '/sys/devices/system/cpu'
+  _KERNEL_MAX = '/sys/devices/system/cpu/kernel_max'
+
+  def __init__(self, device):
+    self._device = device
+    # this will raise an AdbCommandFailedError if no CPU files are found
+    self._cpu_files = self._device.RunShellCommand(
+        'ls -d cpu[0-9]*', cwd=self._CPU_PATH, check_return=True, as_root=True)
+    assert self._cpu_files, 'Failed to detect CPUs.'
+    self._cpu_file_list = ' '.join(self._cpu_files)
+    logging.info('CPUs found: %s', self._cpu_file_list)
+    self._have_mpdecision = self._device.FileExists('/system/bin/mpdecision')
+
+  def SetHighPerfMode(self):
+    """Sets the highest stable performance mode for the device."""
+    try:
+      self._device.EnableRoot()
+    except device_errors.CommandFailedError:
+      message = 'Need root for performance mode. Results may be NOISY!!'
+      logging.warning(message)
+      # Add an additional warning at exit, such that it's clear that any results
+      # may be different/noisy (due to the lack of intended performance mode).
+      atexit.register(logging.warning, message)
+      return
+
+    product_model = self._device.product_model
+    # TODO(epenner): Enable on all devices (http://crbug.com/383566)
+    if 'Nexus 4' == product_model:
+      self._ForceAllCpusOnline(True)
+      if not self._AllCpusAreOnline():
+        logging.warning('Failed to force CPUs online. Results may be NOISY!')
+      self._SetScalingGovernorInternal('performance')
+    elif 'Nexus 5' == product_model:
+      self._ForceAllCpusOnline(True)
+      if not self._AllCpusAreOnline():
+        logging.warning('Failed to force CPUs online. Results may be NOISY!')
+      self._SetScalingGovernorInternal('performance')
+      self._SetScalingMaxFreq(1190400)
+      self._SetMaxGpuClock(200000000)
+    else:
+      self._SetScalingGovernorInternal('performance')
+
+  def SetPerfProfilingMode(self):
+    """Enables all cores for reliable perf profiling."""
+    self._ForceAllCpusOnline(True)
+    self._SetScalingGovernorInternal('performance')
+    if not self._AllCpusAreOnline():
+      if not self._device.HasRoot():
+        raise RuntimeError('Need root to force CPUs online.')
+      raise RuntimeError('Failed to force CPUs online.')
+
+  def SetDefaultPerfMode(self):
+    """Sets the performance mode for the device to its default mode."""
+    if not self._device.HasRoot():
+      return
+    product_model = self._device.product_model
+    if 'Nexus 5' == product_model:
+      if self._AllCpusAreOnline():
+        self._SetScalingMaxFreq(2265600)
+        self._SetMaxGpuClock(450000000)
+
+    governor_mode = {
+        'GT-I9300': 'pegasusq',
+        'Galaxy Nexus': 'interactive',
+        'Nexus 4': 'ondemand',
+        'Nexus 5': 'ondemand',
+        'Nexus 7': 'interactive',
+        'Nexus 10': 'interactive'
+    }.get(product_model, 'ondemand')
+    self._SetScalingGovernorInternal(governor_mode)
+    self._ForceAllCpusOnline(False)
+
+  def GetCpuInfo(self):
+    online = (output.rstrip() == '1' and status == 0
+              for (_, output, status) in self._ForEachCpu('cat "$CPU/online"'))
+    governor = (output.rstrip() if status == 0 else None
+                for (_, output, status)
+                in self._ForEachCpu('cat "$CPU/cpufreq/scaling_governor"'))
+    return zip(self._cpu_files, online, governor)
+
+  def _ForEachCpu(self, cmd):
+    script = '; '.join([
+        'for CPU in %s' % self._cpu_file_list,
+        'do %s' % cmd,
+        'echo -n "%~%$?%~%"',
+        'done'
+    ])
+    output = self._device.RunShellCommand(
+        script, cwd=self._CPU_PATH, check_return=True, as_root=True)
+    output = '\n'.join(output).split('%~%')
+    return zip(self._cpu_files, output[0::2], (int(c) for c in output[1::2]))
+
+  def _WriteEachCpuFile(self, path, value):
+    results = self._ForEachCpu(
+        'test -e "$CPU/{path}" && echo {value} > "$CPU/{path}"'.format(
+            path=path, value=value))
+    cpus = ' '.join(cpu for (cpu, _, status) in results if status == 0)
+    if cpus:
+      logging.info('Successfully set %s to %r on: %s', path, value, cpus)
+    else:
+      logging.warning('Failed to set %s to %r on any cpus', path, value)
+
+  def _SetScalingGovernorInternal(self, value):
+    self._WriteEachCpuFile('cpufreq/scaling_governor', value)
+
+  def _SetScalingMaxFreq(self, value):
+    self._WriteEachCpuFile('cpufreq/scaling_max_freq', '%d' % value)
+
+  def _SetMaxGpuClock(self, value):
+    self._device.WriteFile('/sys/class/kgsl/kgsl-3d0/max_gpuclk',
+                           str(value),
+                           as_root=True)
+
+  def _AllCpusAreOnline(self):
+    results = self._ForEachCpu('cat "$CPU/online"')
+    # TODO(epenner): Investigate why file may be missing
+    # (http://crbug.com/397118)
+    return all(output.rstrip() == '1' and status == 0
+               for (cpu, output, status) in results
+               if cpu != 'cpu0')
+
+  def _ForceAllCpusOnline(self, force_online):
+    """Enable all CPUs on a device.
+
+    Some vendors (or only Qualcomm?) hot-plug their CPUs, which can add noise
+    to measurements:
+    - In perf, samples are only taken for the CPUs that are online when the
+      measurement is started.
+    - The scaling governor can't be set for an offline CPU and frequency scaling
+      on newly enabled CPUs adds noise to both perf and tracing measurements.
+
+    It appears Qualcomm is the only vendor that hot-plugs CPUs, and on Qualcomm
+    this is done by "mpdecision".
+
+    """
+    if self._have_mpdecision:
+      script = 'stop mpdecision' if force_online else 'start mpdecision'
+      self._device.RunShellCommand(script, check_return=True, as_root=True)
+
+    if not self._have_mpdecision and not self._AllCpusAreOnline():
+      logging.warning('Unexpected cpu hot plugging detected.')
+
+    if force_online:
+      self._ForEachCpu('echo 1 > "$CPU/online"')

build/android/pylib/perf/perf_control_unittest.py → build/android/devil/android/perf/perf_control_unittest.py

@@ -10,7 +10,7 @@ import unittest
 sys.path.append(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir))
 
 from devil.android import device_utils
-from pylib.perf import perf_control
+from devil.android.perf import perf_control
 
 class TestPerfControl(unittest.TestCase):
   def setUp(self):

build/android/devil/android/perf/surface_stats_collector.py

+# Copyright 2013 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 Queue
+import threading
+
+
+# Log marker containing SurfaceTexture timestamps.
+_SURFACE_TEXTURE_TIMESTAMPS_MESSAGE = 'SurfaceTexture update timestamps'
+_SURFACE_TEXTURE_TIMESTAMP_RE = r'\d+'
+
+
+class SurfaceStatsCollector(object):
+  """Collects surface stats for a SurfaceView from the output of SurfaceFlinger.
+
+  Args:
+    device: A DeviceUtils instance.
+  """
+
+  def __init__(self, device):
+    self._device = device
+    self._collector_thread = None
+    self._surface_before = None
+    self._get_data_event = None
+    self._data_queue = None
+    self._stop_event = None
+    self._warn_about_empty_data = True
+
+  def DisableWarningAboutEmptyData(self):
+    self._warn_about_empty_data = False
+
+  def Start(self):
+    assert not self._collector_thread
+
+    if self._ClearSurfaceFlingerLatencyData():
+      self._get_data_event = threading.Event()
+      self._stop_event = threading.Event()
+      self._data_queue = Queue.Queue()
+      self._collector_thread = threading.Thread(target=self._CollectorThread)
+      self._collector_thread.start()
+    else:
+      raise Exception('SurfaceFlinger not supported on this device.')
+
+  def Stop(self):
+    assert self._collector_thread
+    (refresh_period, timestamps) = self._GetDataFromThread()
+    if self._collector_thread:
+      self._stop_event.set()
+      self._collector_thread.join()
+      self._collector_thread = None
+    return (refresh_period, timestamps)
+
+  def _CollectorThread(self):
+    last_timestamp = 0
+    timestamps = []
+    retries = 0
+
+    while not self._stop_event.is_set():
+      self._get_data_event.wait(1)
+      try:
+        refresh_period, new_timestamps = self._GetSurfaceFlingerFrameData()
+        if refresh_period is None or timestamps is None:
+          retries += 1
+          if retries < 3:
+            continue
+          if last_timestamp:
+            # Some data has already been collected, but either the app
+            # was closed or there's no new data. Signal the main thread and
+            # wait.
+            self._data_queue.put((None, None))
+            self._stop_event.wait()
+            break
+          raise Exception('Unable to get surface flinger latency data')
+
+        timestamps += [timestamp for timestamp in new_timestamps
+                       if timestamp > last_timestamp]
+        if len(timestamps):
+          last_timestamp = timestamps[-1]
+
+        if self._get_data_event.is_set():
+          self._get_data_event.clear()
+          self._data_queue.put((refresh_period, timestamps))
+          timestamps = []
+      except Exception as e:
+        # On any error, before aborting, put the exception into _data_queue to
+        # prevent the main thread from waiting at _data_queue.get() infinitely.
+        self._data_queue.put(e)
+        raise
+
+  def _GetDataFromThread(self):
+    self._get_data_event.set()
+    ret = self._data_queue.get()
+    if isinstance(ret, Exception):
+      raise ret
+    return ret
+
+  def _ClearSurfaceFlingerLatencyData(self):
+    """Clears the SurfaceFlinger latency data.
+
+    Returns:
+      True if SurfaceFlinger latency is supported by the device, otherwise
+      False.
+    """
+    # The command returns nothing if it is supported, otherwise returns many
+    # lines of result just like 'dumpsys SurfaceFlinger'.
+    results = self._device.RunShellCommand(
+        'dumpsys SurfaceFlinger --latency-clear SurfaceView')
+    return not len(results)
+
+  def GetSurfaceFlingerPid(self):
+    results = self._device.RunShellCommand('ps | grep surfaceflinger')
+    if not results:
+      raise Exception('Unable to get surface flinger process id')
+    pid = results[0].split()[1]
+    return pid
+
+  def _GetSurfaceFlingerFrameData(self):
+    """Returns collected SurfaceFlinger frame timing data.
+
+    Returns:
+      A tuple containing:
+      - The display's nominal refresh period in milliseconds.
+      - A list of timestamps signifying frame presentation times in
+        milliseconds.
+      The return value may be (None, None) if there was no data collected (for
+      example, if the app was closed before the collector thread has finished).
+    """
+    # adb shell dumpsys SurfaceFlinger --latency <window name>
+    # prints some information about the last 128 frames displayed in
+    # that window.
+    # The data returned looks like this:
+    # 16954612
+    # 7657467895508   7657482691352   7657493499756
+    # 7657484466553   7657499645964   7657511077881
+    # 7657500793457   7657516600576   7657527404785
+    # (...)
+    #
+    # The first line is the refresh period (here 16.95 ms), it is followed
+    # by 128 lines w/ 3 timestamps in nanosecond each:
+    # A) when the app started to draw
+    # B) the vsync immediately preceding SF submitting the frame to the h/w
+    # C) timestamp immediately after SF submitted that frame to the h/w
+    #
+    # The difference between the 1st and 3rd timestamp is the frame-latency.
+    # An interesting data is when the frame latency crosses a refresh period
+    # boundary, this can be calculated this way:
+    #
+    # ceil((C - A) / refresh-period)
+    #
+    # (each time the number above changes, we have a "jank").
+    # If this happens a lot during an animation, the animation appears
+    # janky, even if it runs at 60 fps in average.
+    #
+    # We use the special "SurfaceView" window name because the statistics for
+    # the activity's main window are not updated when the main web content is
+    # composited into a SurfaceView.
+    results = self._device.RunShellCommand(
+        'dumpsys SurfaceFlinger --latency SurfaceView')
+    if not len(results):
+      return (None, None)
+
+    timestamps = []
+    nanoseconds_per_millisecond = 1e6
+    refresh_period = long(results[0]) / nanoseconds_per_millisecond
+
+    # If a fence associated with a frame is still pending when we query the
+    # latency data, SurfaceFlinger gives the frame a timestamp of INT64_MAX.
+    # Since we only care about completed frames, we will ignore any timestamps
+    # with this value.
+    pending_fence_timestamp = (1 << 63) - 1
+
+    for line in results[1:]:
+      fields = line.split()
+      if len(fields) != 3:
+        continue
+      timestamp = long(fields[1])
+      if timestamp == pending_fence_timestamp:
+        continue
+      timestamp /= nanoseconds_per_millisecond
+      timestamps.append(timestamp)
+
+    return (refresh_period, timestamps)

build/android/devil/android/perf/thermal_throttle.py

+# Copyright 2013 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 logging
+
+
+class OmapThrottlingDetector(object):
+  """Class to detect and track thermal throttling on an OMAP 4."""
+  OMAP_TEMP_FILE = ('/sys/devices/platform/omap/omap_temp_sensor.0/'
+                    'temperature')
+
+  @staticmethod
+  def IsSupported(device):
+    return device.FileExists(OmapThrottlingDetector.OMAP_TEMP_FILE)
+
+  def __init__(self, device):
+    self._device = device
+
+  @staticmethod
+  def BecameThrottled(log_line):
+    return 'omap_thermal_throttle' in log_line
+
+  @staticmethod
+  def BecameUnthrottled(log_line):
+    return 'omap_thermal_unthrottle' in log_line
+
+  @staticmethod
+  def GetThrottlingTemperature(log_line):
+    if 'throttle_delayed_work_fn' in log_line:
+      return float([s for s in log_line.split() if s.isdigit()][0]) / 1000.0
+
+  def GetCurrentTemperature(self):
+    tempdata = self._device.ReadFile(OmapThrottlingDetector.OMAP_TEMP_FILE)
+    return float(tempdata) / 1000.0
+
+
+class ExynosThrottlingDetector(object):
+  """Class to detect and track thermal throttling on an Exynos 5."""
+  @staticmethod
+  def IsSupported(device):
+    return device.FileExists('/sys/bus/exynos5-core')
+
+  def __init__(self, device):
+    pass
+
+  @staticmethod
+  def BecameThrottled(log_line):
+    return 'exynos_tmu: Throttling interrupt' in log_line
+
+  @staticmethod
+  def BecameUnthrottled(log_line):
+    return 'exynos_thermal_unthrottle: not throttling' in log_line
+
+  @staticmethod
+  def GetThrottlingTemperature(_log_line):
+    return None
+
+  @staticmethod
+  def GetCurrentTemperature():
+    return None
+
+
+class ThermalThrottle(object):
+  """Class to detect and track thermal throttling.
+
+  Usage:
+    Wait for IsThrottled() to be False before running test
+    After running test call HasBeenThrottled() to find out if the
+    test run was affected by thermal throttling.
+  """
+
+  def __init__(self, device):
+    self._device = device
+    self._throttled = False
+    self._detector = None
+    if OmapThrottlingDetector.IsSupported(device):
+      self._detector = OmapThrottlingDetector(device)
+    elif ExynosThrottlingDetector.IsSupported(device):
+      self._detector = ExynosThrottlingDetector(device)
+
+  def HasBeenThrottled(self):
+    """True if there has been any throttling since the last call to
+       HasBeenThrottled or IsThrottled.
+    """
+    return self._ReadLog()
+
+  def IsThrottled(self):
+    """True if currently throttled."""
+    self._ReadLog()
+    return self._throttled
+
+  def _ReadLog(self):
+    if not self._detector:
+      return False
+    has_been_throttled = False
+    serial_number = str(self._device)
+    log = self._device.RunShellCommand('dmesg -c')
+    degree_symbol = unichr(0x00B0)
+    for line in log:
+      if self._detector.BecameThrottled(line):
+        if not self._throttled:
+          logging.warning('>>> Device %s thermally throttled', serial_number)
+        self._throttled = True
+        has_been_throttled = True
+      elif self._detector.BecameUnthrottled(line):
+        if self._throttled:
+          logging.warning('>>> Device %s thermally unthrottled', serial_number)
+        self._throttled = False
+        has_been_throttled = True
+      temperature = self._detector.GetThrottlingTemperature(line)
+      if temperature is not None:
+        logging.info(u'Device %s thermally throttled at %3.1f%sC',
+                     serial_number, temperature, degree_symbol)
+
+    if logging.getLogger().isEnabledFor(logging.DEBUG):
+      # Print current temperature of CPU SoC.
+      temperature = self._detector.GetCurrentTemperature()
+      if temperature is not None:
+        logging.debug(u'Current SoC temperature of %s = %3.1f%sC',
+                      serial_number, temperature, degree_symbol)
+
+      # Print temperature of battery, to give a system temperature
+      dumpsys_log = self._device.RunShellCommand('dumpsys battery')
+      for line in dumpsys_log:
+        if 'temperature' in line:
+          btemp = float([s for s in line.split() if s.isdigit()][0]) / 10.0
+          logging.debug(u'Current battery temperature of %s = %3.1f%sC',
+                        serial_number, btemp, degree_symbol)
+
+    return has_been_throttled
+

build/android/pylib/gtest/test_runner.py

@@ -9,11 +9,11 @@ import tempfile
 
 from devil.android import device_errors
 from devil.android import ports
+from devil.android.perf import perf_control
 from pylib import pexpect
 from pylib.base import base_test_result
 from pylib.base import base_test_runner
 from pylib.local import local_test_server_spawner
-from pylib.perf import perf_control
 
 
 # Test case statuses.

build/android/pylib/perf/cache_control.py

-# Copyright 2013 The Chromium Authors. All rights reserved.
+# Copyright 2015 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.
 
+# pylint: disable=unused-wildcard-import
+# pylint: disable=wildcard-import
 
-class CacheControl(object):
-  _DROP_CACHES = '/proc/sys/vm/drop_caches'
-
-  def __init__(self, device):
-    self._device = device
-
-  def DropRamCaches(self):
-    """Drops the filesystem ram caches for performance testing."""
-    self._device.RunShellCommand('sync', as_root=True)
-    self._device.WriteFile(CacheControl._DROP_CACHES, '3', as_root=True)
-
+from devil.android.perf.cache_control import *

build/android/pylib/perf/perf_control.py

-# Copyright 2013 The Chromium Authors. All rights reserved.
+# Copyright 2015 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 atexit
-import logging
+# pylint: disable=unused-wildcard-import
+# pylint: disable=wildcard-import
 
-from devil.android import device_errors
-
-
-class PerfControl(object):
-  """Provides methods for setting the performance mode of a device."""
-  _CPU_PATH = '/sys/devices/system/cpu'
-  _KERNEL_MAX = '/sys/devices/system/cpu/kernel_max'
-
-  def __init__(self, device):
-    self._device = device
-    # this will raise an AdbCommandFailedError if no CPU files are found
-    self._cpu_files = self._device.RunShellCommand(
-        'ls -d cpu[0-9]*', cwd=self._CPU_PATH, check_return=True, as_root=True)
-    assert self._cpu_files, 'Failed to detect CPUs.'
-    self._cpu_file_list = ' '.join(self._cpu_files)
-    logging.info('CPUs found: %s', self._cpu_file_list)
-    self._have_mpdecision = self._device.FileExists('/system/bin/mpdecision')
-
-  def SetHighPerfMode(self):
-    """Sets the highest stable performance mode for the device."""
-    try:
-      self._device.EnableRoot()
-    except device_errors.CommandFailedError:
-      message = 'Need root for performance mode. Results may be NOISY!!'
-      logging.warning(message)
-      # Add an additional warning at exit, such that it's clear that any results
-      # may be different/noisy (due to the lack of intended performance mode).
-      atexit.register(logging.warning, message)
-      return
-
-    product_model = self._device.product_model
-    # TODO(epenner): Enable on all devices (http://crbug.com/383566)
-    if 'Nexus 4' == product_model:
-      self._ForceAllCpusOnline(True)
-      if not self._AllCpusAreOnline():
-        logging.warning('Failed to force CPUs online. Results may be NOISY!')
-      self._SetScalingGovernorInternal('performance')
-    elif 'Nexus 5' == product_model:
-      self._ForceAllCpusOnline(True)
-      if not self._AllCpusAreOnline():
-        logging.warning('Failed to force CPUs online. Results may be NOISY!')
-      self._SetScalingGovernorInternal('performance')
-      self._SetScalingMaxFreq(1190400)
-      self._SetMaxGpuClock(200000000)
-    else:
-      self._SetScalingGovernorInternal('performance')
-
-  def SetPerfProfilingMode(self):
-    """Enables all cores for reliable perf profiling."""
-    self._ForceAllCpusOnline(True)
-    self._SetScalingGovernorInternal('performance')
-    if not self._AllCpusAreOnline():
-      if not self._device.HasRoot():
-        raise RuntimeError('Need root to force CPUs online.')
-      raise RuntimeError('Failed to force CPUs online.')
-
-  def SetDefaultPerfMode(self):
-    """Sets the performance mode for the device to its default mode."""
-    if not self._device.HasRoot():
-      return
-    product_model = self._device.product_model
-    if 'Nexus 5' == product_model:
-      if self._AllCpusAreOnline():
-        self._SetScalingMaxFreq(2265600)
-        self._SetMaxGpuClock(450000000)
-
-    governor_mode = {
-        'GT-I9300': 'pegasusq',
-        'Galaxy Nexus': 'interactive',
-        'Nexus 4': 'ondemand',
-        'Nexus 5': 'ondemand',
-        'Nexus 7': 'interactive',
-        'Nexus 10': 'interactive'
-    }.get(product_model, 'ondemand')
-    self._SetScalingGovernorInternal(governor_mode)
-    self._ForceAllCpusOnline(False)
-
-  def GetCpuInfo(self):
-    online = (output.rstrip() == '1' and status == 0
-              for (_, output, status) in self._ForEachCpu('cat "$CPU/online"'))
-    governor = (output.rstrip() if status == 0 else None
-                for (_, output, status)
-                in self._ForEachCpu('cat "$CPU/cpufreq/scaling_governor"'))
-    return zip(self._cpu_files, online, governor)
-
-  def _ForEachCpu(self, cmd):
-    script = '; '.join([
-        'for CPU in %s' % self._cpu_file_list,
-        'do %s' % cmd,
-        'echo -n "%~%$?%~%"',
-        'done'
-    ])
-    output = self._device.RunShellCommand(
-        script, cwd=self._CPU_PATH, check_return=True, as_root=True)
-    output = '\n'.join(output).split('%~%')
-    return zip(self._cpu_files, output[0::2], (int(c) for c in output[1::2]))
-
-  def _WriteEachCpuFile(self, path, value):
-    results = self._ForEachCpu(
-        'test -e "$CPU/{path}" && echo {value} > "$CPU/{path}"'.format(
-            path=path, value=value))
-    cpus = ' '.join(cpu for (cpu, _, status) in results if status == 0)
-    if cpus:
-      logging.info('Successfully set %s to %r on: %s', path, value, cpus)
-    else:
-      logging.warning('Failed to set %s to %r on any cpus', path, value)
-
-  def _SetScalingGovernorInternal(self, value):
-    self._WriteEachCpuFile('cpufreq/scaling_governor', value)
-
-  def _SetScalingMaxFreq(self, value):
-    self._WriteEachCpuFile('cpufreq/scaling_max_freq', '%d' % value)
-
-  def _SetMaxGpuClock(self, value):
-    self._device.WriteFile('/sys/class/kgsl/kgsl-3d0/max_gpuclk',
-                           str(value),
-                           as_root=True)
-
-  def _AllCpusAreOnline(self):
-    results = self._ForEachCpu('cat "$CPU/online"')
-    # TODO(epenner): Investigate why file may be missing
-    # (http://crbug.com/397118)
-    return all(output.rstrip() == '1' and status == 0
-               for (cpu, output, status) in results
-               if cpu != 'cpu0')
-
-  def _ForceAllCpusOnline(self, force_online):
-    """Enable all CPUs on a device.
-
-    Some vendors (or only Qualcomm?) hot-plug their CPUs, which can add noise
-    to measurements:
-    - In perf, samples are only taken for the CPUs that are online when the
-      measurement is started.
-    - The scaling governor can't be set for an offline CPU and frequency scaling
-      on newly enabled CPUs adds noise to both perf and tracing measurements.
-
-    It appears Qualcomm is the only vendor that hot-plugs CPUs, and on Qualcomm
-    this is done by "mpdecision".
-
-    """
-    if self._have_mpdecision:
-      script = 'stop mpdecision' if force_online else 'start mpdecision'
-      self._device.RunShellCommand(script, check_return=True, as_root=True)
-
-    if not self._have_mpdecision and not self._AllCpusAreOnline():
-      logging.warning('Unexpected cpu hot plugging detected.')
-
-    if force_online:
-      self._ForEachCpu('echo 1 > "$CPU/online"')
+from devil.android.perf.perf_control import *

build/android/pylib/perf/surface_stats_collector.py

-# Copyright 2013 The Chromium Authors. All rights reserved.
+# Copyright 2015 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 Queue
-import threading
+# pylint: disable=unused-wildcard-import
+# pylint: disable=wildcard-import
 
-
-# Log marker containing SurfaceTexture timestamps.
-_SURFACE_TEXTURE_TIMESTAMPS_MESSAGE = 'SurfaceTexture update timestamps'
-_SURFACE_TEXTURE_TIMESTAMP_RE = r'\d+'
-
-
-class SurfaceStatsCollector(object):
-  """Collects surface stats for a SurfaceView from the output of SurfaceFlinger.
-
-  Args:
-    device: A DeviceUtils instance.
-  """
-
-  def __init__(self, device):
-    self._device = device
-    self._collector_thread = None
-    self._surface_before = None
-    self._get_data_event = None
-    self._data_queue = None
-    self._stop_event = None
-    self._warn_about_empty_data = True
-
-  def DisableWarningAboutEmptyData(self):
-    self._warn_about_empty_data = False
-
-  def Start(self):
-    assert not self._collector_thread
-
-    if self._ClearSurfaceFlingerLatencyData():
-      self._get_data_event = threading.Event()
-      self._stop_event = threading.Event()
-      self._data_queue = Queue.Queue()
-      self._collector_thread = threading.Thread(target=self._CollectorThread)
-      self._collector_thread.start()
-    else:
-      raise Exception('SurfaceFlinger not supported on this device.')
-
-  def Stop(self):
-    assert self._collector_thread
-    (refresh_period, timestamps) = self._GetDataFromThread()
-    if self._collector_thread:
-      self._stop_event.set()
-      self._collector_thread.join()
-      self._collector_thread = None
-    return (refresh_period, timestamps)
-
-  def _CollectorThread(self):
-    last_timestamp = 0
-    timestamps = []
-    retries = 0
-
-    while not self._stop_event.is_set():
-      self._get_data_event.wait(1)
-      try:
-        refresh_period, new_timestamps = self._GetSurfaceFlingerFrameData()
-        if refresh_period is None or timestamps is None:
-          retries += 1
-          if retries < 3:
-            continue
-          if last_timestamp:
-            # Some data has already been collected, but either the app
-            # was closed or there's no new data. Signal the main thread and
-            # wait.
-            self._data_queue.put((None, None))
-            self._stop_event.wait()
-            break
-          raise Exception('Unable to get surface flinger latency data')
-
-        timestamps += [timestamp for timestamp in new_timestamps
-                       if timestamp > last_timestamp]
-        if len(timestamps):
-          last_timestamp = timestamps[-1]
-
-        if self._get_data_event.is_set():
-          self._get_data_event.clear()
-          self._data_queue.put((refresh_period, timestamps))
-          timestamps = []
-      except Exception as e:
-        # On any error, before aborting, put the exception into _data_queue to
-        # prevent the main thread from waiting at _data_queue.get() infinitely.
-        self._data_queue.put(e)
-        raise
-
-  def _GetDataFromThread(self):
-    self._get_data_event.set()
-    ret = self._data_queue.get()
-    if isinstance(ret, Exception):
-      raise ret
-    return ret
-
-  def _ClearSurfaceFlingerLatencyData(self):
-    """Clears the SurfaceFlinger latency data.
-
-    Returns:
-      True if SurfaceFlinger latency is supported by the device, otherwise
-      False.
-    """
-    # The command returns nothing if it is supported, otherwise returns many
-    # lines of result just like 'dumpsys SurfaceFlinger'.
-    results = self._device.RunShellCommand(
-        'dumpsys SurfaceFlinger --latency-clear SurfaceView')
-    return not len(results)
-
-  def GetSurfaceFlingerPid(self):
-    results = self._device.RunShellCommand('ps | grep surfaceflinger')
-    if not results:
-      raise Exception('Unable to get surface flinger process id')
-    pid = results[0].split()[1]
-    return pid
-
-  def _GetSurfaceFlingerFrameData(self):
-    """Returns collected SurfaceFlinger frame timing data.
-
-    Returns:
-      A tuple containing:
-      - The display's nominal refresh period in milliseconds.
-      - A list of timestamps signifying frame presentation times in
-        milliseconds.
-      The return value may be (None, None) if there was no data collected (for
-      example, if the app was closed before the collector thread has finished).
-    """
-    # adb shell dumpsys SurfaceFlinger --latency <window name>
-    # prints some information about the last 128 frames displayed in
-    # that window.
-    # The data returned looks like this:
-    # 16954612
-    # 7657467895508   7657482691352   7657493499756
-    # 7657484466553   7657499645964   7657511077881
-    # 7657500793457   7657516600576   7657527404785
-    # (...)
-    #
-    # The first line is the refresh period (here 16.95 ms), it is followed
-    # by 128 lines w/ 3 timestamps in nanosecond each:
-    # A) when the app started to draw
-    # B) the vsync immediately preceding SF submitting the frame to the h/w
-    # C) timestamp immediately after SF submitted that frame to the h/w
-    #
-    # The difference between the 1st and 3rd timestamp is the frame-latency.
-    # An interesting data is when the frame latency crosses a refresh period
-    # boundary, this can be calculated this way:
-    #
-    # ceil((C - A) / refresh-period)
-    #
-    # (each time the number above changes, we have a "jank").
-    # If this happens a lot during an animation, the animation appears
-    # janky, even if it runs at 60 fps in average.
-    #
-    # We use the special "SurfaceView" window name because the statistics for
-    # the activity's main window are not updated when the main web content is
-    # composited into a SurfaceView.
-    results = self._device.RunShellCommand(
-        'dumpsys SurfaceFlinger --latency SurfaceView')
-    if not len(results):
-      return (None, None)
-
-    timestamps = []
-    nanoseconds_per_millisecond = 1e6
-    refresh_period = long(results[0]) / nanoseconds_per_millisecond
-
-    # If a fence associated with a frame is still pending when we query the
-    # latency data, SurfaceFlinger gives the frame a timestamp of INT64_MAX.
-    # Since we only care about completed frames, we will ignore any timestamps
-    # with this value.
-    pending_fence_timestamp = (1 << 63) - 1
-
-    for line in results[1:]:
-      fields = line.split()
-      if len(fields) != 3:
-        continue
-      timestamp = long(fields[1])
-      if timestamp == pending_fence_timestamp:
-        continue
-      timestamp /= nanoseconds_per_millisecond
-      timestamps.append(timestamp)
-
-    return (refresh_period, timestamps)
+from devil.android.perf.surface_stats_collector import *

build/android/pylib/perf/thermal_throttle.py

-# Copyright 2013 The Chromium Authors. All rights reserved.
+# Copyright 2015 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 logging
-
-
-class OmapThrottlingDetector(object):
-  """Class to detect and track thermal throttling on an OMAP 4."""
-  OMAP_TEMP_FILE = ('/sys/devices/platform/omap/omap_temp_sensor.0/'
-                    'temperature')
-
-  @staticmethod
-  def IsSupported(device):
-    return device.FileExists(OmapThrottlingDetector.OMAP_TEMP_FILE)
-
-  def __init__(self, device):
-    self._device = device
-
-  @staticmethod
-  def BecameThrottled(log_line):
-    return 'omap_thermal_throttle' in log_line
-
-  @staticmethod
-  def BecameUnthrottled(log_line):
-    return 'omap_thermal_unthrottle' in log_line
-
-  @staticmethod
-  def GetThrottlingTemperature(log_line):
-    if 'throttle_delayed_work_fn' in log_line:
-      return float([s for s in log_line.split() if s.isdigit()][0]) / 1000.0
-
-  def GetCurrentTemperature(self):
-    tempdata = self._device.ReadFile(OmapThrottlingDetector.OMAP_TEMP_FILE)
-    return float(tempdata) / 1000.0
-
-
-class ExynosThrottlingDetector(object):
-  """Class to detect and track thermal throttling on an Exynos 5."""
-  @staticmethod
-  def IsSupported(device):
-    return device.FileExists('/sys/bus/exynos5-core')
-
-  def __init__(self, device):
-    pass
-
-  @staticmethod
-  def BecameThrottled(log_line):
-    return 'exynos_tmu: Throttling interrupt' in log_line
-
-  @staticmethod
-  def BecameUnthrottled(log_line):
-    return 'exynos_thermal_unthrottle: not throttling' in log_line
-
-  @staticmethod
-  def GetThrottlingTemperature(_log_line):
-    return None
-
-  @staticmethod
-  def GetCurrentTemperature():
-    return None
-
-
-class ThermalThrottle(object):
-  """Class to detect and track thermal throttling.
-
-  Usage:
-    Wait for IsThrottled() to be False before running test
-    After running test call HasBeenThrottled() to find out if the
-    test run was affected by thermal throttling.
-  """
-
-  def __init__(self, device):
-    self._device = device
-    self._throttled = False
-    self._detector = None
-    if OmapThrottlingDetector.IsSupported(device):
-      self._detector = OmapThrottlingDetector(device)
-    elif ExynosThrottlingDetector.IsSupported(device):
-      self._detector = ExynosThrottlingDetector(device)
-
-  def HasBeenThrottled(self):
-    """True if there has been any throttling since the last call to
-       HasBeenThrottled or IsThrottled.
-    """
-    return self._ReadLog()
-
-  def IsThrottled(self):
-    """True if currently throttled."""
-    self._ReadLog()
-    return self._throttled
-
-  def _ReadLog(self):
-    if not self._detector:
-      return False
-    has_been_throttled = False
-    serial_number = str(self._device)
-    log = self._device.RunShellCommand('dmesg -c')
-    degree_symbol = unichr(0x00B0)
-    for line in log:
-      if self._detector.BecameThrottled(line):
-        if not self._throttled:
-          logging.warning('>>> Device %s thermally throttled', serial_number)
-        self._throttled = True
-        has_been_throttled = True
-      elif self._detector.BecameUnthrottled(line):
-        if self._throttled:
-          logging.warning('>>> Device %s thermally unthrottled', serial_number)
-        self._throttled = False
-        has_been_throttled = True
-      temperature = self._detector.GetThrottlingTemperature(line)
-      if temperature is not None:
-        logging.info(u'Device %s thermally throttled at %3.1f%sC',
-                     serial_number, temperature, degree_symbol)
-
-    if logging.getLogger().isEnabledFor(logging.DEBUG):
-      # Print current temperature of CPU SoC.
-      temperature = self._detector.GetCurrentTemperature()
-      if temperature is not None:
-        logging.debug(u'Current SoC temperature of %s = %3.1f%sC',
-                      serial_number, temperature, degree_symbol)
-
-      # Print temperature of battery, to give a system temperature
-      dumpsys_log = self._device.RunShellCommand('dumpsys battery')
-      for line in dumpsys_log:
-        if 'temperature' in line:
-          btemp = float([s for s in line.split() if s.isdigit()][0]) / 10.0
-          logging.debug(u'Current battery temperature of %s = %3.1f%sC',
-                        serial_number, btemp, degree_symbol)
-
-    return has_been_throttled
+# pylint: disable=unused-wildcard-import
+# pylint: disable=wildcard-import
 
+from devil.android.perf.thermal_throttle import *

tools/profile_chrome/chrome_startup_controller.py

@@ -6,9 +6,9 @@ import os
 import re
 import time
 
+from devil.android.perf import cache_control
+from devil.android.sdk import intent
 from pylib import flag_changer
-from pylib.device import intent
-from pylib.perf import cache_control
 
 from profile_chrome import controllers
 

tools/profile_chrome/perf_controller.py

@@ -9,12 +9,13 @@ import subprocess
 import sys
 import tempfile
 
+from devil.android import device_temp_file
+from devil.android.perf import perf_control
+
 from profile_chrome import controllers
 from profile_chrome import ui
 
 from pylib import constants
-from pylib.perf import perf_control
-from pylib.utils import device_temp_file
 
 sys.path.append(os.path.join(constants.DIR_SOURCE_ROOT,
                              'tools',

tools/telemetry/telemetry/internal/platform/android_platform_backend.py

@@ -38,15 +38,15 @@ import platformsettings
 from devil.android import battery_utils
 from devil.android import device_errors
 from devil.android import device_utils
+from devil.android.perf import cache_control
+from devil.android.perf import perf_control
+from devil.android.perf import thermal_throttle
 from devil.android.sdk import version_codes
 from pylib import constants
 from pylib import screenshot
-from pylib.perf import cache_control
-from pylib.perf import perf_control
-from pylib.perf import thermal_throttle
 
 try:
-  from pylib.perf import surface_stats_collector
+  from devil.android.perf import surface_stats_collector
 except Exception:
   surface_stats_collector = None
 

tools/telemetry/telemetry/internal/platform/profiler/perf_profiler.py

@@ -17,7 +17,7 @@ from telemetry.core import platform
 from telemetry.internal.platform import profiler
 from telemetry.internal.platform.profiler import android_profiling_helper
 
-from pylib.perf import perf_control  # pylint: disable=F0401
+from devil.android.perf import perf_control  # pylint: disable=F0401
 
 
 _PERF_OPTIONS = [