SurfaceStats / Telemetry: calculate FPS in different frame buckets.

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 67 matching lines @@
         SurfaceStatsCollector.Result('max_frame_delay', None, 'vsyncs'),
         SurfaceStatsCollector.Result('frame_lengths', None, 'vsyncs'),
         SurfaceStatsCollector.Result('avg_surface_fps', None, 'fps')
     ]
 
   @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])
 
+  @staticmethod
+  def _CalculateResults(refresh_period, timestamps, result_suffix):
+    """Returns a list of SurfaceStatsCollector.Result."""
+    frame_count = len(timestamps)
+    seconds = timestamps[-1] - timestamps[0]
+
+    frame_lengths, normalized_frame_lengths = \
+        SurfaceStatsCollector._GetNormalizedDeltas(timestamps, refresh_period)
+    length_changes, normalized_changes = \
+        SurfaceStatsCollector._GetNormalizedDeltas(
+            frame_lengths, refresh_period)
+    jankiness = [max(0, round(change)) for change in normalized_changes]
+    pause_threshold = 20
+    jank_count = sum(1 for change in jankiness
+                     if change > 0 and change < pause_threshold)
+    return [
+        SurfaceStatsCollector.Result(
+            'avg_surface_fps' + result_suffix,
+            int(round(frame_count / seconds)), 'fps'),
+        SurfaceStatsCollector.Result(
+            'jank_count' + result_suffix, jank_count, 'janks'),
+        SurfaceStatsCollector.Result(
+            'max_frame_delay' + result_suffix,
+            round(max(normalized_frame_lengths)),
+            'vsyncs'),
+        SurfaceStatsCollector.Result(
+            'frame_lengths' + result_suffix, normalized_frame_lengths,
+            'vsyncs'),
+    ]
+
+  @staticmethod
+  def _CalculateBuckets(refresh_period, timestamps):
+    results = []
+    for pct in [0.99, 0.5]:
+      sliced = timestamps[int(-pct * len(timestamps)) + 3 : ]
+      results += SurfaceStatsCollector._CalculateResults(
+          refresh_period, sliced, '_' + str(int(pct * 100)))
+    return results
+
   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:
-        if self._warn_about_empty_data:
-          logging.warning('Surface stat data is empty')
-        return
-      frame_count = len(timestamps)
-      seconds = timestamps[-1] - timestamps[0]
+      self._results.append(SurfaceStatsCollector.Result(
+          'avg_surface_fps', int(round(frame_count / seconds)), 'fps'))
+      return
 
-      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
-      jank_count = sum(1 for change in jankiness
-                       if change > 0 and change < pause_threshold)
-
-      self._results.append(SurfaceStatsCollector.Result(
-          'refresh_period', refresh_period, 'seconds'))
-      self._results.append(SurfaceStatsCollector.Result(
-          'jank_count', jank_count, 'janks'))
-      self._results.append(SurfaceStatsCollector.Result(
-          'max_frame_delay', round(max(normalized_frame_lengths)),
-          'vsyncs'))
-      self._results.append(SurfaceStatsCollector.Result(
-          'frame_lengths', normalized_frame_lengths, 'vsyncs'))
+    # Non-legacy method.
+    assert self._collector_thread
+    (refresh_period, timestamps) = self._GetDataFromThread()
+    if not refresh_period or not len(timestamps) >= 3:
+      if self._warn_about_empty_data:
+        logging.warning('Surface stat data is empty')
+      return
     self._results.append(SurfaceStatsCollector.Result(
-        'avg_surface_fps', int(round(frame_count / seconds)), 'fps'))
+        'refresh_period', refresh_period, 'seconds'))
+    self._results += self._CalculateResults(refresh_period, timestamps, '')
+    self._results += self._CalculateBuckets(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()
@@ skipping 129 matching lines @@
       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(),
     }