Telemetry: Filter invalid frame lengths from SurfaceFlinger data.

build/android/pylib/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 datetime
 import logging
 import re
 import threading
 
 
 # Log marker containing SurfaceTexture timestamps.
 _SURFACE_TEXTURE_TIMESTAMPS_MESSAGE = 'SurfaceTexture update timestamps'
 _SURFACE_TEXTURE_TIMESTAMP_RE = '\d+'
 
+_MIN_NORMALIZED_FRAME_LENGTH = 0.5
+
 
 class SurfaceStatsCollector(object):
   """Collects surface stats for a SurfaceView from the output of SurfaceFlinger.
 
   Args:
     adb: the adb connection to use.
   """
   class Result(object):
     def __init__(self, name, value, unit):
       self.name = name
@@ skipping 46 matching lines @@
   def _GetEmptyResults(self):
     return [
         SurfaceStatsCollector.Result('refresh_period', None, 'seconds'),
         SurfaceStatsCollector.Result('jank_count', None, 'janks'),
         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):
+  def _GetNormalizedDeltas(data, refresh_period, min_normalized_delta=None):
     deltas = [t2 - t1 for t1, t2 in zip(data, data[1:])]
+    if min_normalized_delta != None:
+      deltas = filter(lambda d: d / refresh_period >= min_normalized_delta,
+                      deltas)
     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)
+        SurfaceStatsCollector._GetNormalizedDeltas(
+            timestamps, refresh_period, _MIN_NORMALIZED_FRAME_LENGTH)
+    if len(frame_lengths) < frame_count - 1:
+      logging.warning('Skipping frame lengths that are too short.')
+      frame_count = len(frame_lengths) + 1
+    if len(frame_lengths) == 0:
+      raise Exception('No valid frames lengths found.')
     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'),
+            int(round((frame_count - 1) / 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'),
     ]
@@ skipping 172 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(),
     }