Telemetry on android: improves RawDisplayFrameRateMeasurement.

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
 
 from pylib import perf_tests_helper
 
 
 # Log marker containing SurfaceTexture timestamps.
 _SURFACE_TEXTURE_TIMESTAMPS_MESSAGE = 'SurfaceTexture update timestamps'
 _SURFACE_TEXTURE_TIMESTAMP_RE = '\d+'
 
 
 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
+      self.value = value
+      self.unit = unit
+
   def __init__(self, adb, trace_tag):
     self._adb = adb
     self._trace_tag = trace_tag
     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._print_perf_results = True
+    self._results = []
 
   def __enter__(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 __exit__(self, *args):
+    self._StorePerfResults()
     self._PrintPerfResults()
     if self._collector_thread:
       self._stop_event.set()
       self._collector_thread.join()
       self._collector_thread = None
 
+  def GetResults(self):
+    return self._results
+
+  def SuppressPrintingResults(self):
+    self._print_perf_results = False
+
   def _PrintPerfResults(self):
+    if not self._print_perf_results:
+      return
+    for r in self._results:
+      perf_tests_helper.PrintPerfResult(r.name, r.name + self._trace_tag,
+                                        r.value, r.unit)
+
+  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
       (seconds, latencies) = self._GetDataFromThread()
       if not seconds or not len(latencies):
         logging.warning('Surface stat data is empty')
         return
 
       frame_count = len(latencies)
       jitter_count = 0
       last_latency = latencies[0]
       for latency in latencies[1:]:
         if latency > last_latency:
           jitter_count = jitter_count + 1
         last_latency = latency
 
-      perf_tests_helper.PrintPerfResult(
-          'surface_latencies', 'surface_latencies' + self._trace_tag,
-          latencies, '')
-      perf_tests_helper.PrintPerfResult(
-          'peak_jitter', 'peak_jitter' + self._trace_tag, [max(latencies)], '')
-      perf_tests_helper.PrintPerfResult(
-          'jitter_percent', 'jitter_percent' + self._trace_tag,
-          [jitter_count * 100.0 / frame_count], 'percent')
-
-    print 'SurfaceMonitorTime: %fsecs' % seconds
-    perf_tests_helper.PrintPerfResult(
-        'avg_surface_fps', 'avg_surface_fps' + self._trace_tag,
-        [int(round(frame_count / seconds))], 'fps')
+      self._results.append(SurfaceStatsCollector.Result(
+          'surface_latencies', latencies, ''))
+      self._results.append(SurfaceStatsCollector.Result(
+          'peak_jitter', [max(latencies)], ''))
+      self._results.append(SurfaceStatsCollector.Result(
+          'jitter_percent', [jitter_count * 100.0 / frame_count], 'percent'))
+    self._results.append(SurfaceStatsCollector.Result(
+          'avg_surface_fps', [int(round(frame_count / seconds))], 'fps'))
 
   def _CollectorThread(self):
     last_timestamp = 0
     first_timestamp = 0
     latencies = []
     retries = 0
     has_collected_data = False
 
     while not self._stop_event.is_set():
       self._get_data_event.wait(1)
@@ skipping 134 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(),
     }