android: Add interactive surface statistics viewer

build/android/pylib/surface_stats_collector.py

 # Copyright (c) 2012 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 datetime
 import logging
 import re
 import threading
 
@@ skipping 19 matching lines @@
 
   def __init__(self, adb):
     self._adb = adb
     self._collector_thread = None
     self._use_legacy_method = False
     self._surface_before = None
     self._get_data_event = None
     self._data_queue = None
     self._stop_event = None
     self._results = []
+    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:
       self._use_legacy_method = True
       self._surface_before = self._GetSurfaceStatsLegacy()
 
   def Stop(self):
     self._StorePerfResults()
     if self._collector_thread:
       self._stop_event.set()
       self._collector_thread.join()
       self._collector_thread = None
 
+  def SampleResults(self):
+    self._StorePerfResults()
+    results = self._results
+    self._results = []
+    return results
+
   def GetResults(self):
     return self._results
 
   @staticmethod
   def _GetNormalizedDeltas(data, refresh_period):
     deltas = [t2 - t1 for t1, t2 in zip(data, data[1:])]
     return (deltas, [delta / refresh_period for delta in deltas])
 
   def _StorePerfResults(self):
     if self._use_legacy_method:
       surface_after = self._GetSurfaceStatsLegacy()
       td = surface_after['timestamp'] - self._surface_before['timestamp']
       seconds = td.seconds + td.microseconds / 1e6
       frame_count = (surface_after['page_flip_count'] -
                      self._surface_before['page_flip_count'])
     else:
       assert self._collector_thread
       (refresh_period, timestamps) = self._GetDataFromThread()
       if not refresh_period or not len(timestamps) >= 3:
-        logging.warning('Surface stat data is empty')
+        if self._warn_about_empty_data:
+          logging.warning('Surface stat data is empty')
         return
       frame_count = len(timestamps)
       seconds = timestamps[-1] - timestamps[0]
 
       frame_lengths, normalized_frame_lengths = \
           self._GetNormalizedDeltas(timestamps, refresh_period)
       length_changes, normalized_changes = \
           self._GetNormalizedDeltas(frame_lengths, refresh_period)
       jankiness = [max(0, round(change)) for change in normalized_changes]
       pause_threshold = 20
@@ skipping 110 matching lines @@
     # composited into a SurfaceView.
     results = self._adb.RunShellCommand(
         'dumpsys SurfaceFlinger --latency SurfaceView', log_result=True)
     if not len(results):
       return (None, None)
 
     timestamps = []
     nanoseconds_per_second = 1e9
     refresh_period = long(results[0]) / nanoseconds_per_second
 
+    # SurfaceFlinger sometimes gives an invalid timestamp for the very latest
+    # frame if it is queried while the frame is still being presented. We ignore
+    # these timestamps.
+    bad_timestamp = (1 << 63) - 1
+
     for line in results[1:]:
       fields = line.split()
       if len(fields) != 3:
         continue
-      timestamp = long(fields[1]) / nanoseconds_per_second
+      timestamp = long(fields[1])
+      if timestamp == bad_timestamp:
+        continue
+      timestamp /= nanoseconds_per_second
       timestamps.append(timestamp)
 
     return (refresh_period, timestamps)
 
   def _GetSurfaceStatsLegacy(self):
     """Legacy method (before JellyBean), returns the current Surface index
        and timestamp.
 
     Calculate FPS by measuring the difference of Surface index returned by
     SurfaceFlinger in a period of time.
 
     Returns:
       Dict of {page_flip_count (or 0 if there was an error), timestamp}.
     """
     results = self._adb.RunShellCommand('service call SurfaceFlinger 1013')
     assert len(results) == 1
     match = re.search('^Result: Parcel\((\w+)', results[0])
     cur_surface = 0
     if match:
       try:
         cur_surface = int(match.group(1), 16)
       except Exception:
         logging.error('Failed to parse current surface from ' + match.group(1))
     else:
       logging.warning('Failed to call SurfaceFlinger surface ' + results[0])
     return {
         'page_flip_count': cur_surface,
         'timestamp': datetime.datetime.now(),
     }