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])
 
+  def _CalcFpsInBuckets(self, timestamps):
+    for pct in [0.9, 0.5]:
+      sliced = timestamps[int(-pct * len(timestamps)) + 3 : ]

[Sami, 2013/07/03 15:11:50]

Probably want to bail out here if there were too few samples.

[bulach, 2013/07/03 18:09:15]

when is the "legacy" method used? the non-legacy guarantees there'll be at least
three samples.. I can check it in here too, or...remove the legacy method ? :)

[Sami, 2013/07/03 18:21:37]

Ah, good point. The legacy path is only used on pre-JB devices. I think we want
to keep that around since devices like S3 are still on ICS. I don't think we
need to implement windowing there, though.

+      seconds = sliced[-1] - sliced[0]
+      frame_count = len(sliced)
+      self._results.append(SurfaceStatsCollector.Result(
+          'avg_surface_fps_' + str(pct).replace('.', '_'),

[Sami, 2013/07/03 15:11:50]

int(pct * 100) would gives nicer names I think :)

[bulach, 2013/07/03 18:09:15]

indeed! done.

+          int(round(frame_count / seconds)), 'fps'))
+
   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()
@@ skipping 17 matching lines @@
           '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'))
     self._results.append(SurfaceStatsCollector.Result(
         'avg_surface_fps', int(round(frame_count / seconds)), 'fps'))
+    self._CalcFpsInBuckets(timestamps)

[Sami, 2013/07/03 15:11:50]

If we decide to go ahead with this, let's include jank_count, max_frame_delay
and frame_lengths too.

[bulach, 2013/07/03 18:09:15]

I need to understand this better though: they all depend on "refresh_period",
which seems to be for the entire set?
that is, jank_count depends on normalized_changes which depends on this
"refresh_period"... can we derive "refresh_period" from the trimmed timestamps
instead, i.e., "seconds"?

[Sami, 2013/07/03 18:21:37]

|refresh_period| is a constant given by the display panel and is used to
normalize/threshold the data in |timestamps|. That is, it's used to derive these
metrics and not the other way around.

One way this could work is to move the loop here:

  for pct in [0.5, 0.9]:
    trimmed_timestamps = timestamps[int(-pct * len(timestamps)) + 3 : ]
    seconds = trimmed_timestamps[-1] - trimmed_timestamps[0]
    frame_count = len(trimmed_timestamps)
    self._results.append(SurfaceStatsCollector.Result(
        'avg_surface_fps' + suffix, int(round(frame_count / seconds)), 'fps'))
    frame_lengths, normalized_frame_lengths = \
        self._GetNormalizedDeltas(trimmed_timestamps, refresh_period)
    ...
    self._results.append(SurfaceStatsCollector.Result(
          'frame_lengths' + suffix, normalized_frame_lengths, 'vsyncs'))
    [etc.]

 
   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(),
     }