telemetry: separated stats collection from metrics calculation.

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
 
 class SmoothnessMetrics(object):
   def __init__(self, tab):
     self._tab = tab
@@ skipping 33 matching lines @@
   @property
   def end_values(self):
     return self._tab.EvaluateJavaScript(
       'window.__renderingStats.getEndValues()')
 
   @property
   def deltas(self):
     return self._tab.EvaluateJavaScript(
       'window.__renderingStats.getDeltas()')
 
-
-def DivideIfPossibleOrZero(numerator, denominator):
+def Average(numerator, denominator, scale = None, precision = None):
   if denominator == 0:
     return 0
-  return numerator / denominator
-
-def CalcScrollResults(rendering_stats_deltas, results):
-  num_frames_sent_to_screen = rendering_stats_deltas['numFramesSentToScreen']
-
-  mean_frame_time_seconds = (
-    rendering_stats_deltas['totalTimeInSeconds'] /
-      float(num_frames_sent_to_screen))
-
-  dropped_percent = (
-    rendering_stats_deltas['droppedFrameCount'] /
-    float(num_frames_sent_to_screen))
-
-  num_impl_thread_scrolls = rendering_stats_deltas.get(
-    'numImplThreadScrolls', 0)
-  num_main_thread_scrolls = rendering_stats_deltas.get(
-    'numMainThreadScrolls', 0)
-
-  percent_impl_scrolled = DivideIfPossibleOrZero(
-    float(num_impl_thread_scrolls),
-    num_impl_thread_scrolls + num_main_thread_scrolls)
-
-  num_layers = (
-      rendering_stats_deltas.get('numLayersDrawn', 0) /
-      float(num_frames_sent_to_screen))
-
-  num_missing_tiles = (
-      rendering_stats_deltas.get('numMissingTiles', 0) /
-      float(num_frames_sent_to_screen))
-
-  results.Add('mean_frame_time', 'ms', round(mean_frame_time_seconds * 1000, 3))
-  results.Add('dropped_percent', '%', round(dropped_percent * 100, 1),
-              data_type='unimportant')
-  results.Add('percent_impl_scrolled', '%',
-              round(percent_impl_scrolled * 100, 1),
-              data_type='unimportant')
-  results.Add('average_num_layers_drawn', '', round(num_layers, 1),
-              data_type='unimportant')
-  results.Add('average_num_missing_tiles', '', round(num_missing_tiles, 1),
-              data_type='unimportant')
-
-def CalcTextureUploadResults(rendering_stats_deltas, results):
-  if (('totalCommitCount' not in rendering_stats_deltas)
-      or rendering_stats_deltas['totalCommitCount'] == 0) :
-    averageCommitTimeMs = 0
-  else :
-    averageCommitTimeMs = (
-        1000 * rendering_stats_deltas['totalCommitTimeInSeconds'] /
-        rendering_stats_deltas['totalCommitCount'])
-
-  results.Add('texture_upload_count', 'count',
-              rendering_stats_deltas.get('textureUploadCount', 0))
-  results.Add('total_texture_upload_time', 'seconds',
-              rendering_stats_deltas.get('totalTextureUploadTimeInSeconds', 0))
-  results.Add('average_commit_time', 'ms', averageCommitTimeMs,
-              data_type='unimportant')
+  avg = float(numerator) / float(denominator)
+  if scale:
+    avg *= scale
+  if precision:
+    avg = round(avg, precision)
+  return avg
 
 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 CalcImageDecodingResults(rendering_stats_deltas, results):
-  totalDeferredImageDecodeCount = rendering_stats_deltas.get(
-      'totalDeferredImageDecodeCount', 0)
-  totalDeferredImageCacheHitCount = rendering_stats_deltas.get(
-      'totalDeferredImageCacheHitCount', 0)
-  totalImageGatheringCount = rendering_stats_deltas.get(
-      'totalImageGatheringCount', 0)
-  totalDeferredImageDecodeTimeInSeconds = rendering_stats_deltas.get(
-      'totalDeferredImageDecodeTimeInSeconds', 0)
-  totalImageGatheringTimeInSeconds = rendering_stats_deltas.get(
-      'totalImageGatheringTimeInSeconds', 0)
+def CalcResults(benchmark_stats, results):
+  s = benchmark_stats
 
-  averageImageGatheringTime = DivideIfPossibleOrZero(
-      (totalImageGatheringTimeInSeconds * 1000), totalImageGatheringCount)
+  # Scroll Results
+  results.Add('mean_frame_time', 'ms',
+              Average(s['total_time'], s['screen_frame_count'], 1000, 3))
+  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')
+  results.Add('average_num_layers_drawn', '',
+              Average(s['drawn_layers_count'], s['screen_frame_count'], 1, 1),
+              data_type='unimportant')
+  results.Add('average_num_missing_tiles', '',
+              Average(s['missing_tile_count'], s['screen_frame_count'], 1, 1),
+              data_type='unimportant')
 
+  # Texture Upload Results
+  results.Add('average_commit_time', 'ms',
+              Average(s['commit_time'], s['commit_count'], 1000, 3),
+              data_type='unimportant')
+  results.Add('texture_upload_count', 'count',
+              s['texture_upload_count'])
+  results.Add('total_texture_upload_time', 'seconds',
+              s['texture_upload_time'])
+
+  # Image Decoding Results
   results.Add('total_deferred_image_decode_count', 'count',
-              totalDeferredImageDecodeCount,
+              s['deferred_image_decode_count'],
               data_type='unimportant')
   results.Add('total_image_cache_hit_count', 'count',
-              totalDeferredImageCacheHitCount,
+              s['deferred_image_cache_hits'],
               data_type='unimportant')
-  results.Add('average_image_gathering_time', 'ms', averageImageGatheringTime,
+  results.Add('average_image_gathering_time', 'ms',
+              Average(s['image_gathering_time'], s['image_gathering_count'],
+                      1000, 3),
               data_type='unimportant')
   results.Add('total_deferred_image_decoding_time', 'seconds',
-              totalDeferredImageDecodeTimeInSeconds,
+              s['deferred_image_decode_time'],
               data_type='unimportant')
 
-def CalcAnalysisResults(rendering_stats_deltas, results):
-  totalTilesAnalyzed = rendering_stats_deltas.get(
-      'totalTilesAnalyzed', 0)
-  solidColorTilesAnalyzed = rendering_stats_deltas.get(
-      'solidColorTilesAnalyzed', 0)
-  totalTileAnalysisTimeInSeconds = rendering_stats_deltas.get(
-      'totalTileAnalysisTimeInSeconds', 0)
-
-  averageAnalysisTimeMS = \
-      1000 * DivideIfPossibleOrZero(totalTileAnalysisTimeInSeconds,
-                                    totalTilesAnalyzed)
-
+  # Tile Analysis Results
   results.Add('total_tiles_analyzed', 'count',
-              totalTilesAnalyzed,
+              s['tile_analysis_count'],
               data_type='unimportant')
   results.Add('solid_color_tiles_analyzed', 'count',
-              solidColorTilesAnalyzed,
+              s['solid_color_tile_analysis_count'],
               data_type='unimportant')
   results.Add('average_tile_analysis_time', 'ms',
-              averageAnalysisTimeMS,
+              Average(s['tile_analysis_time'], s['tile_analysis_count'],
+                      1000, 3),
               data_type='unimportant')
 
-def CalcLatency(rendering_stats_deltas, count_name, total_latency_name,
-                result_name, results):
-  eventCount = rendering_stats_deltas.get(count_name, 0)
-  totalLatencyInSeconds = rendering_stats_deltas.get(total_latency_name, 0)
-  averageLatency = DivideIfPossibleOrZero(
-      (totalLatencyInSeconds * 1000), eventCount)
-  results.Add(result_name, 'ms', averageLatency, data_type='unimportant')
-
-def CalcLatencyResults(rendering_stats_deltas, results):
-  CalcLatency(rendering_stats_deltas, 'inputEventCount', 'totalInputLatency',
-              'average_latency', results)
-  CalcLatency(rendering_stats_deltas, 'touchUICount', 'totalTouchUILatency',
-              'average_touch_ui_latency', results)
-  CalcLatency(rendering_stats_deltas, 'touchAckedCount',
-              'totalTouchAckedLatency',
-              'average_touch_acked_latency',
-              results)
-  CalcLatency(rendering_stats_deltas, 'scrollUpdateCount',
-              'totalScrollUpdateLatency',
-              'average_scroll_update_latency', results)
+  # Latency Results
+  results.Add('average_latency', 'ms',
+              Average(s['input_event_latency'], s['input_event_count'],
+                      1000, 3),
+              data_type='unimportant')
+  results.Add('average_touch_ui_latency', 'ms',
+              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')