Convert V8GCTimes measurement to timeline based measurement.

tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py

Index: tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
diff --git a/tools/perf/measurements/v8_gc_times.py b/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
similarity index 62%
copy from tools/perf/measurements/v8_gc_times.py
copy to tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
index b7e7e8ea46ad765ed83c52e2c2ddb5df639b8a60..163f518d67ff80475353d8b301e85c881c4b8fe0 100644
--- a/tools/perf/measurements/v8_gc_times.py
+++ b/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
@@ -2,61 +2,48 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-from telemetry.page import page_test
-from telemetry.timeline.model import TimelineModel
-from telemetry.timeline import tracing_category_filter
-from telemetry.timeline import tracing_options
 from telemetry.util import statistics
+from telemetry.value import improvement_direction
 from telemetry.value import scalar
+from telemetry.web_perf.metrics import timeline_based_metric
 
+class V8EventStat(object):
+
+  def __init__(self, src_event_name, result_name, result_description):
+    self.src_event_name = src_event_name
+    self.result_name = result_name
+    self.result_description = result_description
+    self.thread_duration = 0.0
+    self.thread_duration_inside_idle = 0.0
+    self.idle_task_overrun_duration = 0.0
+    self.max_thread_duration = 0.0
+    self.count = 0
+
+  @property
+  def thread_duration_outside_idle(self):
+    return self.thread_duration - self.thread_duration_inside_idle
 
-class V8GCTimes(page_test.PageTest):
+  @property
+  def percentage_thread_duration_during_idle(self):
+    return statistics.DivideIfPossibleOrZero(
+        100 * self.thread_duration_inside_idle, self.thread_duration)
 
-  _TIME_OUT_IN_SECONDS = 60
-  _CATEGORIES = ['blink.console',
-                 'renderer.scheduler',
-                 'v8',
-                 'webkit.console']
+class V8GCLatency(timeline_based_metric.TimelineBasedMetric):
   _RENDERER_MAIN_THREAD = 'CrRendererMain'
   _IDLE_TASK_PARENT = 'SingleThreadIdleTaskRunner::RunTask'
 
   def __init__(self):
-    super(V8GCTimes, self).__init__()
-
-  def WillNavigateToPage(self, page, tab):
-    category_filter = tracing_category_filter.TracingCategoryFilter()
-
-    for category in self._CATEGORIES:
-      category_filter.AddIncludedCategory(category)
+    super(V8GCLatency, self).__init__()
 
-    options = tracing_options.TracingOptions()
-    options.enable_chrome_trace = True
+  def AddResults(self, model, renderer_thread, interaction_records, results):
+    self.VerifyNonOverlappedRecords(interaction_records)
+    self._AddV8MetricsToResults(model, interaction_records, results)
 
-    tab.browser.platform.tracing_controller.Start(
-        options, category_filter, self._TIME_OUT_IN_SECONDS)
+  def _AddV8MetricsToResults(self, model,
+                             interaction_records, results):
+    self._AddV8EventStatsToResults(model, interaction_records, results)
 
-  def ValidateAndMeasurePage(self, page, tab, results):
-    trace_data = tab.browser.platform.tracing_controller.Stop()
-    timeline_model = TimelineModel(trace_data)
-    renderer_process = timeline_model.GetRendererProcessFromTabId(tab.id)
-    self._AddV8MetricsToResults(renderer_process, results)
-
-  def DidRunPage(self, platform):
-    if platform.tracing_controller.is_tracing_running:
-      platform.tracing_controller.Stop()
-
-  def _AddV8MetricsToResults(self, process, results):
-    if process is None:
-      return
-
-    for thread in process.threads.values():
-      if thread.name != self._RENDERER_MAIN_THREAD:
-        continue
-
-      self._AddV8EventStatsToResults(thread, results)
-      self._AddCpuTimeStatsToResults(thread, results)
-
-  def _AddV8EventStatsToResults(self, thread, results):
+  def _AddV8EventStatsToResults(self, model, interactions, results):
     v8_event_stats = [
         V8EventStat('V8.GCIncrementalMarking',
                     'v8_gc_incremental_marking',
@@ -67,18 +54,19 @@ class V8GCTimes(page_test.PageTest):
         V8EventStat('V8.GCCompactor',
                     'v8_gc_mark_compactor',
                     'mark-sweep-compactor')]
-    # Find all V8 GC events in the trace.
-    for event in thread.IterAllSlices():
-      event_stat = _FindV8EventStatForEvent(v8_event_stats, event.name)
-      if not event_stat:
+    label = interactions[0].label
+    name_to_v8_stat = {x.src_event_name : x for x in v8_event_stats}
+    for event in model.IterAllSlices():
+      if (not timeline_based_metric.IsEventInInteractions(event, interactions)
+          or not event.name in name_to_v8_stat):
         continue
-
+      event_stat = name_to_v8_stat[event.name]
       event_stat.thread_duration += event.thread_duration
       event_stat.max_thread_duration = max(event_stat.max_thread_duration,
                                            event.thread_duration)
       event_stat.count += 1
 
-      parent_idle_task = _ParentIdleTask(event)
+      parent_idle_task = self._ParentIdleTask(event)
       if parent_idle_task:
         allotted_idle_time = parent_idle_task.args['allotted_time_ms']
         idle_task_wall_overrun = 0
@@ -93,46 +81,57 @@ class V8GCTimes(page_test.PageTest):
             event.duration - idle_task_wall_overrun, event.duration)
         event_stat.thread_duration_inside_idle += inside_idle
         event_stat.idle_task_overrun_duration += idle_task_wall_overrun
-
     for v8_event_stat in v8_event_stats:
       results.AddValue(scalar.ScalarValue(
           results.current_page, v8_event_stat.result_name, 'ms',
           v8_event_stat.thread_duration,
           description=('Total thread duration spent in %s' %
-                       v8_event_stat.result_description)))
+                       v8_event_stat.result_description),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
       results.AddValue(scalar.ScalarValue(
           results.current_page, '%s_max' % v8_event_stat.result_name, 'ms',
           v8_event_stat.max_thread_duration,
           description=('Max thread duration spent in %s' %
-                       v8_event_stat.result_description)))
+                       v8_event_stat.result_description),
+          tir_label=label))
       results.AddValue(scalar.ScalarValue(
           results.current_page, '%s_count' % v8_event_stat.result_name, 'count',
           v8_event_stat.count,
           description=('Number of %s' %
-                       v8_event_stat.result_description)))
+                       v8_event_stat.result_description),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
       average_thread_duration = statistics.DivideIfPossibleOrZero(
           v8_event_stat.thread_duration, v8_event_stat.count)
       results.AddValue(scalar.ScalarValue(
           results.current_page, '%s_average' % v8_event_stat.result_name, 'ms',
           average_thread_duration,
           description=('Average thread duration spent in %s' %
-                       v8_event_stat.result_description)))
+                       v8_event_stat.result_description),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
       results.AddValue(scalar.ScalarValue(results.current_page,
           '%s_outside_idle' % v8_event_stat.result_name, 'ms',
           v8_event_stat.thread_duration_outside_idle,
           description=(
               'Total thread duration spent in %s outside of idle tasks' %
-              v8_event_stat.result_description)))
+              v8_event_stat.result_description),
+          tir_label=label))
       results.AddValue(scalar.ScalarValue(results.current_page,
           '%s_idle_deadline_overrun' % v8_event_stat.result_name, 'ms',
           v8_event_stat.idle_task_overrun_duration,
           description=('Total idle task deadline overrun for %s idle tasks'
-                       % v8_event_stat.result_description)))
+                       % v8_event_stat.result_description),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
       results.AddValue(scalar.ScalarValue(results.current_page,
           '%s_percentage_idle' % v8_event_stat.result_name, 'idle%',
           v8_event_stat.percentage_thread_duration_during_idle,
           description=('Percentage of %s spent in idle time' %
-                       v8_event_stat.result_description)))
+                       v8_event_stat.result_description),
+          tir_label=label,
+          improvement_direction=improvement_direction.UP))
 
     # Add total metrics.
     gc_total = sum(x.thread_duration for x in v8_event_stats)
@@ -145,73 +144,37 @@ class V8GCTimes(page_test.PageTest):
 
     results.AddValue(scalar.ScalarValue(results.current_page,
         'v8_gc_total', 'ms', gc_total,
-        description='Total thread duration of all garbage collection events'))
+        description='Total thread duration of all garbage collection events',
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
     results.AddValue(scalar.ScalarValue(results.current_page,
         'v8_gc_total_outside_idle', 'ms', gc_total_outside_idle,
         description=(
             'Total thread duration of all garbage collection events outside of '
-            'idle tasks')))
+            'idle tasks'),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
     results.AddValue(scalar.ScalarValue(results.current_page,
         'v8_gc_total_idle_deadline_overrun', 'ms',
         gc_total_idle_deadline_overrun,
         description=(
             'Total idle task deadline overrun for all idle tasks garbage '
-            'collection events')))
+            'collection events'),
+          tir_label=label,
+          improvement_direction=improvement_direction.DOWN))
     results.AddValue(scalar.ScalarValue(results.current_page,
         'v8_gc_total_percentage_idle', 'idle%', gc_total_percentage_idle,
         description=(
             'Percentage of the thread duration of all garbage collection '
-            'events spent inside of idle tasks')))
-
-  def _AddCpuTimeStatsToResults(self, thread, results):
-    if thread.toplevel_slices:
-      start_time = min(s.start for s in thread.toplevel_slices)
-      end_time = max(s.end for s in thread.toplevel_slices)
-      duration = end_time - start_time
-      cpu_time = sum(s.thread_duration for s in thread.toplevel_slices)
-    else:
-      duration = cpu_time = 0
-
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'duration', 'ms', duration))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'cpu_time', 'ms', cpu_time))
-
-
-def _FindV8EventStatForEvent(v8_event_stats_list, event_name):
-  for v8_event_stat in v8_event_stats_list:
-    if v8_event_stat.src_event_name == event_name:
-      return v8_event_stat
-  return None
-
-
-def _ParentIdleTask(event):
-  parent = event.parent_slice
-  while parent:
-    # pylint: disable=protected-access
-    if parent.name == V8GCTimes._IDLE_TASK_PARENT:
-      return parent
-    parent = parent.parent_slice
-  return None
-
-
-class V8EventStat(object):
-
-  def __init__(self, src_event_name, result_name, result_description):
-    self.src_event_name = src_event_name
-    self.result_name = result_name
-    self.result_description = result_description
-    self.thread_duration = 0.0
-    self.thread_duration_inside_idle = 0.0
-    self.idle_task_overrun_duration = 0.0
-    self.max_thread_duration = 0.0
-    self.count = 0
-
-  @property
-  def thread_duration_outside_idle(self):
-    return self.thread_duration - self.thread_duration_inside_idle
+            'events spent inside of idle tasks'),
+          tir_label=label,
+          improvement_direction=improvement_direction.UP))
+
+  def _ParentIdleTask(self, event):
+    parent = event.parent_slice
+    while parent:
+      if parent.name == self._IDLE_TASK_PARENT:
+        return parent
+      parent = parent.parent_slice
+    return None
 
-  @property
-  def percentage_thread_duration_during_idle(self):
-    return statistics.DivideIfPossibleOrZero(
-        100 * self.thread_duration_inside_idle, self.thread_duration)