Collecting LatencyInfo in telemetry

tools/perf/metrics/smoothness.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.
 
 from metrics import Metric
 from metrics import rendering_stats
 from metrics import statistics
 from telemetry.page import page_measurement
 
 TIMELINE_MARKER = 'Smoothness'
@@ skipping 46 matching lines @@
 
   def Stop(self, page, tab):
     if tab.browser.platform.IsRawDisplayFrameRateSupported():
       tab.browser.platform.StopRawDisplayFrameRateMeasurement()
     tab.ExecuteJavaScript('console.timeEnd("' + TIMELINE_MARKER + '")')
     timeline_model = tab.browser.StopTracing().AsTimelineModel()
     timeline_ranges = [ action.GetActiveRangeOnTimeline(timeline_model)
                         for action in self._actions ]
 
     renderer_process = timeline_model.GetRendererProcessFromTab(tab)
+    browser_main_thread = timeline_model.GetBrowserMainThread()
+
     self._stats = rendering_stats.RenderingStats(
-        renderer_process, timeline_ranges)
+        renderer_process, browser_main_thread, timeline_ranges)
 
     if not self._stats.frame_times:
       raise NotEnoughFramesError()
 
   def SetStats(self, stats):
     """ Pass in a RenderingStats object directly. For unittests that don't call
         Start/Stop.
     """
     self._stats = stats
 
   def AddResults(self, tab, results):
+    if self._stats.mouse_wheel_latency:
+      mean_mouse_wheel_latency = statistics.ArithmeticMean(
+          self._stats.mouse_wheel_latency, len(self._stats.mouse_wheel_latency))
+      results.Add('mean_mouse_wheel_latency', 'ms',
+                  round(mean_mouse_wheel_latency, 3))
+      results.Add('mouse_wheel_latency_75%', 'ms',
+                  statistics.Percentile(self._stats.mouse_wheel_latency, 75.0) )
+
+    if self._stats.gesture_scroll_latency:
+      mean_gesture_scroll_latency = statistics.ArithmeticMean(
+          self._stats.gesture_scroll_latency,
+          len(self._stats.gesture_scroll_latency))
+      results.Add('mean_gesture_scroll_latency', 'ms',
+                  round(mean_gesture_scroll_latency, 3))
+      results.Add('gesture_scroll_latency_75%', 'ms',

[Rick Byers, 2014/01/21 13:57:17]

Has there been any discussion of what the right metric to use is here?  To me
75th percentile doesn't seem much more useful than median.  Can we bump this up
to 90th or 95th without the results on our pagesets getting too noisy?

[Yufeng Shen (Slow to review), 2014/01/22 23:23:35]

Done.

[Rick Byers, 2014/01/23 00:57:05]

Thanks.  How consistent does this tend to be from run-to-run on Android?  On
Aura I know we have inconsistent scheduling that'll add noise, but hopefully we
can get this to be relatively stable on Android.

+                  statistics.Percentile(self._stats.gesture_scroll_latency,
+                                        75.0) )
+
+    if self._stats.touch_scroll_latency:
+      mean_touch_scroll_latency = statistics.ArithmeticMean(
+          self._stats.touch_scroll_latency,
+          len(self._stats.touch_scroll_latency))
+      results.Add('mean_touch_scroll_latency', 'ms',
+                  round(mean_touch_scroll_latency, 3))
+      results.Add('touch_scroll_latency_75%', 'ms',
+                  statistics.Percentile(self._stats.touch_scroll_latency,
+                                        75.0) )
     # List of raw frame times.
     results.Add('frame_times', 'ms', self._stats.frame_times)
 
     # Arithmetic mean of frame times.
     mean_frame_time = statistics.ArithmeticMean(self._stats.frame_times,
                                                 len(self._stats.frame_times))
     results.Add('mean_frame_time', 'ms', round(mean_frame_time, 3))
 
     # Absolute discrepancy of frame time stamps.
     jank = statistics.FrameDiscrepancy(self._stats.frame_timestamps)
     results.Add('jank', '', round(jank, 4))
 
     # Are we hitting 60 fps for 95 percent of all frames?
     # We use 19ms as a somewhat looser threshold, instead of 1000.0/60.0.
     percentile_95 = statistics.Percentile(self._stats.frame_times, 95.0)
     results.Add('mostly_smooth', 'score', 1.0 if percentile_95 < 19.0 else 0.0)
 
     if tab.browser.platform.IsRawDisplayFrameRateSupported():
       for r in tab.browser.platform.GetRawDisplayFrameRateMeasurements():
         if r.value is None:
           raise MissingDisplayFrameRateError(r.name)
         results.Add(r.name, r.unit, r.value)