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 Median(values):
+  if not values:
+    return 0.0
+  values.sort()
+  n = len(values)
+  if n % 2:
+    median = values[n/2]
+  else:
+    median = 0.5 * (values[n/2] + values[n/2 - 1])
+  return median
+
 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):
   s = benchmark_stats
 
+  frame_times = []
+  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))
+  # Absolute discrepancy of frame time stamps (experimental)
+  results.Add('experimental_jank', '',
+              round(discrepancy.FrameDiscrepancy(s.screen_frame_timestamps,
+                                                 True), 4))
+  # Generalized mean frame time with exponent=2 (experimental)
+  results.Add('experimental_mean_frame_time', '',
+              round(GeneralizedMean(frame_times, 2.0), 2))
+  # Median frame time (experimental)
+  results.Add('experimental_median_frame_time', '',
+              round(Median(frame_times), 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')