Delete tools/telemetry.

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/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py b/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
deleted file mode 100644
index 9d385f6c0bcb74fc9a68f34f522a433f84655afa..0000000000000000000000000000000000000000
--- a/tools/telemetry/telemetry/web_perf/metrics/v8_gc_latency.py
+++ /dev/null
@@ -1,199 +0,0 @@
-# Copyright 2015 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.util import statistics
-from telemetry.value import improvement_direction
-from telemetry.value import scalar
-from telemetry.web_perf.metrics import timeline_based_metric
-
-import logging
-
-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
-
-  @property
-  def percentage_thread_duration_during_idle(self):
-    return statistics.DivideIfPossibleOrZero(
-        100 * self.thread_duration_inside_idle, self.thread_duration)
-
-class V8GCLatency(timeline_based_metric.TimelineBasedMetric):
-  _RENDERER_MAIN_THREAD = 'CrRendererMain'
-  _IDLE_TASK_PARENT = 'SingleThreadIdleTaskRunner::RunTask'
-
-  def __init__(self):
-    super(V8GCLatency, self).__init__()
-
-  def AddResults(self, model, renderer_thread, interaction_records, results):
-    self.VerifyNonOverlappedRecords(interaction_records)
-    self._AddV8MetricsToResults(model, interaction_records, results)
-
-  def _AddV8MetricsToResults(self, model,
-                             interaction_records, results):
-    self._AddV8EventStatsToResults(model, interaction_records, results)
-
-  def _AddV8EventStatsToResults(self, model, interactions, results):
-    v8_event_stats = [
-        V8EventStat('V8.GCIncrementalMarking',
-                    'v8_gc_incremental_marking',
-                    'incremental marking steps'),
-        V8EventStat('V8.GCScavenger',
-                    'v8_gc_scavenger',
-                    'scavenges'),
-        V8EventStat('V8.GCCompactor',
-                    'v8_gc_mark_compactor',
-                    'mark-sweep-compactor'),
-        V8EventStat('V8.GCFinalizeMC',
-                    'v8_gc_finalize_incremental',
-                    'finalization of incremental marking'),
-        V8EventStat('V8.GCFinalizeMCReduceMemory',
-                    'v8_gc_finalize_incremental_reduce_memory',
-                    'finalization of incremental marking with memory reducer')]
-    label = interactions[0].label
-    name_to_v8_stat = {x.src_event_name : x for x in v8_event_stats}
-    thread_time_not_available = False
-    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]
-      if event.thread_duration is None:
-        thread_time_not_available = True
-        event_duration = event.duration
-      else:
-        event_duration = event.thread_duration
-      event_stat.thread_duration += event_duration
-      event_stat.max_thread_duration = max(event_stat.max_thread_duration,
-                                           event_duration)
-      event_stat.count += 1
-
-      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
-        if event.duration > allotted_idle_time:
-          idle_task_wall_overrun = event.duration - allotted_idle_time
-        # Don't count time over the deadline as being inside idle time.
-        # Since the deadline should be relative to wall clock we compare
-        # allotted_time_ms with wall duration instead of thread duration, and
-        # then assume the thread duration was inside idle for the same
-        # percentage of time.
-        inside_idle = event_duration * statistics.DivideIfPossibleOrZero(
-            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
-
-    if thread_time_not_available:
-      logging.warning(
-          'thread time is not available in trace data, switch to walltime')
-
-    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),
-          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),
-          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),
-          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),
-          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),
-          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),
-          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),
-          tir_label=label,
-          improvement_direction=improvement_direction.UP))
-
-    # Add total metrics.
-    gc_total = sum(x.thread_duration for x in v8_event_stats)
-    gc_total_outside_idle = sum(
-        x.thread_duration_outside_idle for x in v8_event_stats)
-    gc_total_idle_deadline_overrun = sum(
-        x.idle_task_overrun_duration for x in v8_event_stats)
-    gc_total_percentage_idle = statistics.DivideIfPossibleOrZero(
-        100 * (gc_total - gc_total_outside_idle), gc_total)
-
-    results.AddValue(scalar.ScalarValue(results.current_page,
-        'v8_gc_total', 'ms', gc_total,
-        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'),
-          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'),
-          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'),
-          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
-