telemetry: Replace mostly_smooth by percentage_smooth.

tools/telemetry/telemetry/web_perf/metrics/smoothness.py

 # Copyright 2014 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 telemetry.perf_tests_helper import FlattenList
 from telemetry.util import statistics
 from telemetry.value import list_of_scalar_values
 from telemetry.value import scalar
 from telemetry.web_perf.metrics import rendering_stats
 from telemetry.web_perf.metrics import timeline_based_metric
@@ skipping 12 matching lines @@
 class SmoothnessMetric(timeline_based_metric.TimelineBasedMetric):
   """Computes metrics that measure smoothness of animations over given ranges.
 
   Animations are typically considered smooth if the frame rates are close to
   60 frames per second (fps) and uniformly distributed over the sequence. To
   determine if a timeline range contains a smooth animation, we update the
   results object with several representative metrics:
 
     frame_times: A list of raw frame times
     mean_frame_time: The arithmetic mean of frame times
-    mostly_smooth: Whether we hit 60 fps for 95% of all frames
+    percentage_smooth: Percentage of frames that were hitting 60 FPS.
     jank: The absolute discrepancy of frame timestamps
     mean_pixels_approximated: The mean percentage of pixels approximated
     queueing_durations: The queueing delay between compositor & main threads
 
   Note that if any of the interaction records provided to AddResults have less
   than 2 frames, we will return telemetry values with None values for each of
   the smoothness metrics. Similarly, older browsers without support for
   tracking the BeginMainFrame events will report a ListOfScalarValues with a
   None value for the queueing duration metric.
   """
@@ skipping 95 matching lines @@
                     'the compositor and renderer threads are. It is the amount '
                     'of wall time that elapses between a '
                     'ScheduledActionSendBeginMainFrame event in the compositor '
                     'thread and the corresponding BeginMainFrame event in the '
                     'main thread.',
         none_value_reason=none_value_reason)
 
   def _ComputeFrameTimeMetric(self, page, stats):
     """Returns Values for the frame time metrics.
 
-    This includes the raw and mean frame times, as well as the mostly_smooth
-    metric which tracks whether we hit 60 fps for 95% of the frames.
+    This includes the raw and mean frame times, as well as the percentage of
+    frames that were hitting 60 fps.

[qyearsley, 2014/10/10 04:02:21]

Since smooth_threshold below is 19.0, is this actually the percentage of frames
that hit 52.6 fps?

[ernstm, 2014/10/10 20:13:08]

I lowered the threshold to 17.0ms. We will be able to do this more accurately
when we get surface flinger time stamps into the metric.

     """
     frame_times = None
     mean_frame_time = None
-    mostly_smooth = None
+    percentage_smooth = None
     none_value_reason = None
     if self._HasEnoughFrames(stats.frame_timestamps):
       frame_times = FlattenList(stats.frame_times)
       mean_frame_time = round(statistics.ArithmeticMean(frame_times), 3)
       # We use 19ms as a somewhat looser threshold, instead of 1000.0/60.0.
-      percentile_95 = statistics.Percentile(frame_times, 95.0)
-      mostly_smooth = 1.0 if percentile_95 < 19.0 else 0.0
+      smooth_threshold = 19.0
+      smooth_count = sum(1 for t in frame_times if t < smooth_threshold)
+      percentage_smooth = float(smooth_count) / len(frame_times) * 100.0
     else:
       none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE
     return (
         list_of_scalar_values.ListOfScalarValues(
             page, 'frame_times', 'ms', frame_times,
             description='List of raw frame times, helpful to understand the '
                         'other metrics.',
             none_value_reason=none_value_reason),
         scalar.ScalarValue(
             page, 'mean_frame_time', 'ms', mean_frame_time,
             description='Arithmetic mean of frame times.',
             none_value_reason=none_value_reason),
         scalar.ScalarValue(
-            page, 'mostly_smooth', 'score', mostly_smooth,
-            description='Were 95 percent of the frames hitting 60 fps?'
-                        'boolean value (1/0).',
+            page, 'percentage_smooth', 'score', percentage_smooth,
+            description='Percentage of frames that were hitting 60 fps.',
             none_value_reason=none_value_reason)
     )
 
   def _ComputeFrameTimeDiscrepancy(self, page, stats):
     """Returns a Value for the absolute discrepancy of frame time stamps."""
 
     frame_discrepancy = None
     none_value_reason = None
     if self._HasEnoughFrames(stats.frame_timestamps):
       frame_discrepancy = round(statistics.TimestampsDiscrepancy(
@@ skipping 22 matching lines @@
     if self._HasEnoughFrames(stats.frame_timestamps):
       mean_pixels_approximated = round(statistics.ArithmeticMean(
           FlattenList(stats.approximated_pixel_percentages)), 3)
     else:
       none_value_reason = NOT_ENOUGH_FRAMES_MESSAGE
     return scalar.ScalarValue(
         page, 'mean_pixels_approximated', 'percent', mean_pixels_approximated,
         description='Percentage of pixels that were approximated '
                     '(checkerboarding, low-resolution tiles, etc.).',
         none_value_reason=none_value_reason)