telemetry: Add new metrics to smoothness benchmark.

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.
 import os
 
 from telemetry.core import util
+from metrics import discrepancy
 
 TIMELINE_MARKER = 'smoothness_scroll'
 
 class SmoothnessMetrics(object):
   def __init__(self, tab):
     self._tab = tab
     with open(
       os.path.join(os.path.dirname(__file__),
                    'smoothness.js')) as f:
       js = f.read()
@@ skipping 64 matching lines @@
   denominator_total = Total(denominator)
   if denominator_total == 0:
     return 0
   avg = numerator_total / denominator_total
   if scale:
     avg *= scale
   if precision:
     avg = round(avg, precision)
   return avg
 
+def DivideIfPossibleOrZero(numerator, denominator):
+  if not denominator:
+    return 0.0
+  else:
+    return numerator / denominator
+
+def GeneralizedMean(values, exponent):
+  ''' http://en.wikipedia.org/wiki/Generalized_mean '''
+  if not values:
+    return 0.0
+  sum_of_powers = 0.0
+  for v in values:
+    sum_of_powers += v ** exponent
+  return (sum_of_powers / len(values)) ** (1.0/exponent)
+
 def CalcFirstPaintTimeResults(results, tab):
   if tab.browser.is_content_shell:
     results.Add('first_paint', 'ms', 'unsupported')
     return
 
   tab.ExecuteJavaScript("""
       window.__rafFired = false;
       window.webkitRequestAnimationFrame(function() {
           window.__rafFired  = true;
       });
   """)
   util.WaitFor(lambda: tab.EvaluateJavaScript('window.__rafFired'), 60)
 
   first_paint_secs = tab.EvaluateJavaScript(
       'window.chrome.loadTimes().firstPaintTime - ' +
       'window.chrome.loadTimes().startLoadTime')
 
   results.Add('first_paint', 'ms', round(first_paint_secs * 1000, 1))
 
 def CalcResults(benchmark_stats, results):

[nduca, 2013/09/05 17:57:41]

you're saying screen frame throughout here but as far as i can tell this is impl
thread frames no? how do you reconcile these names with reality as we go toward
ubercomp etc?

[ernstm, 2013/09/05 18:38:07]

The name originates from the numFramesSentToScreen field in the stats returned
by GpuBenchmarkingExtension, used in the old smoothness implementation. It can
represent impl thread frames or frames submitted in
RenderWidget::DoDeferredUpdated in legacy software mode. Maybe we should just
drop the 'screen' and put some documentation into the code that explains what
exactly the time stamps, etc. represent?

   s = benchmark_stats
 
+  frame_times = []

[nduca, 2013/09/05 17:57:41]

screen_frame_xxx here and elsewhere

+  for i in xrange(1, len(s.screen_frame_timestamps)):
+    frame_times.append(
+        s.screen_frame_timestamps[i] - s.screen_frame_timestamps[i-1])
+
   # Scroll Results
   results.Add('mean_frame_time', 'ms',
               Average(s.total_time, s.screen_frame_count, 1000, 3))
+  results.Add('absolute_frame_discrepancy', '',
+              round(discrepancy.FrameDiscrepancy(s.screen_frame_timestamps,
+                                                 True), 4))
+  results.Add('relative_frame_discrepancy', '',

[nduca, 2013/09/05 17:57:41]

people are going to be very confused about the difference between absolute and
relative. can we pick one and stick with it?

[ernstm, 2013/09/05 18:38:07]

I've put in both, so that we can evaluate which one works best in practice. I
personally believe we should use the absolute discrepancy in combination with
the inverse RMS frame time. Absolute discrepancy quantifies the worst jank
(independent of the  number of good frames) and inverse RMS frame time
characterizes the average experience during the entire scroll. If we just use
the absolute discrepancy, we can drop the 'absolute' from the name.

+              round(discrepancy.FrameDiscrepancy(s.screen_frame_timestamps,
+                                                 False), 4))
+  results.Add('inverse_rms_frame_time', '',
+              round(DivideIfPossibleOrZero(1000.0,

[nduca, 2013/09/05 17:57:41]

this is the key metric, no? can we make this less about the way we compute it
and more about it being the frame time people should pay attention to?
frame_time perhaps.

And, can we deprecate mean_frame_time?

[ernstm, 2013/09/05 18:38:07]

The thing about this metric is that the exponent in the generalized mean allows
us to blend between the average frame time and the maximum frame time. The
inverse is similar to frame rate, but it is not the same (except when all frame
times are equal). We could call it generalized_frame_rate, or power_frame_rate
(generalized mean is also called power mean).

+                                           GeneralizedMean(frame_times, 2.0)),
+                    2))
   results.Add('dropped_percent', '%',
               Average(s.dropped_frame_count, s.screen_frame_count,
                       100, 1),
               data_type='unimportant')
   results.Add('percent_impl_scrolled', '%',
               Average(s.impl_thread_scroll_count,
                       s.impl_thread_scroll_count +
                       s.main_thread_scroll_count,
                       100, 1),
               data_type='unimportant')
@@ skipping 49 matching lines @@
               Average(s.touch_ui_latency, s.touch_ui_count, 1000, 3),
               data_type='unimportant')
   results.Add('average_touch_acked_latency', 'ms',
               Average(s.touch_acked_latency, s.touch_acked_count,
                       1000, 3),
               data_type='unimportant')
   results.Add('average_scroll_update_latency', 'ms',
               Average(s.scroll_update_latency, s.scroll_update_count,
                       1000, 3),
               data_type='unimportant')