Telemetry: Use mimimum tracing for timeline benchmarks.

tools/perf/metrics/timeline.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.
 import collections
 import itertools
 
 from metrics import Metric
 from telemetry.core.timeline import bounds
 from telemetry.page import page_measurement
 
 TRACING_MODE = 'tracing-mode'
 TIMELINE_MODE = 'timeline-mode'
 

[nduca, 2014/02/20 05:35:05]

eric how about pulling out the poll_cpu patch from the rest of this? the rest of
stuff here is a net improvement, even without the base edits... and though I
want the base edits, I think we will feel better having the rest landed faster.

+# All tracing categories not disabled-by-default
+DEFAULT_TRACE_CATEGORIES = None
+
+# Categories for absolute minimum overhead tracing. This contains no
+# sub-traces of thread tasks, so it's only useful for capturing the
+# cpu-time spent on threads (as well as needed benchmark traces)
+MINIMAL_TRACE_CATEGORIES = ("disabled-by-default-benchmark.poll_cpu,"
+                            "benchmark,"
+                            "webkit.console,"
+                            "trace_event_overhead")
 
 class MissingFramesError(page_measurement.MeasurementFailure):
   def __init__(self):
     super(MissingFramesError, self).__init__(
         'No frames found in trace. Unable to normalize results.')
 
 
 class TimelineMetric(Metric):
   def __init__(self, mode):
     """ Initializes a TimelineMetric object.
     """
     super(TimelineMetric, self).__init__()
     assert mode in (TRACING_MODE, TIMELINE_MODE)
+    self.trace_categories = DEFAULT_TRACE_CATEGORIES
     self._mode = mode
     self._model = None
     self._renderer_process = None
     self._actions = []
     self._action_ranges = []
 
   def Start(self, page, tab):
     """Starts gathering timeline data.
 
     mode: TRACING_MODE or TIMELINE_MODE
     """
     self._model = None
     if self._mode == TRACING_MODE:
       if not tab.browser.supports_tracing:
         raise Exception('Not supported')
-      tab.browser.StartTracing()
+      tab.browser.StartTracing(self.trace_categories)
     else:
       assert self._mode == TIMELINE_MODE
       tab.StartTimelineRecording()
 
   def Stop(self, page, tab):
     if self._mode == TRACING_MODE:
       trace_result = tab.browser.StopTracing()
       self._model = trace_result.AsTimelineModel()
       self._renderer_process = self._model.GetRendererProcessFromTab(tab)
       self._action_ranges = [ action.GetActiveRangeOnTimeline(self._model)
@@ skipping 144 matching lines @@
     thread_category = TimelineThreadCategories[thread_name]
   return thread_category
 
 def ThreadTimeResultName(thread_category):
   return "thread_" + thread_category + "_clock_time_per_frame"
 
 def ThreadCpuTimeResultName(thread_category):
   return "thread_" + thread_category + "_cpu_time_per_frame"
 
 def ThreadDetailResultName(thread_category, detail):
-  return "thread_" + thread_category + "|" + detail
+  detail_sanitized = detail.replace('.','_')
+  return "thread_" + thread_category + "|" + detail_sanitized
 
 
 class ResultsForThread(object):
   def __init__(self, model, action_ranges, name):
     self.model = model
     self.toplevel_slices = []
     self.all_slices = []
     self.name = name
     self.action_ranges = action_ranges
 
@@ skipping 27 matching lines @@
         if action_range.Contains(bounds.Bounds.CreateFromEvent(event)):
           slices_in_actions.append(event)
           break
     return slices_in_actions
 
   def AppendThreadSlices(self, thread):
     self.all_slices.extend(self.SlicesInActions(thread.all_slices))
     self.toplevel_slices.extend(self.SlicesInActions(thread.toplevel_slices))
 
   def AddResults(self, num_frames, results):
-    clock_report_name = ThreadTimeResultName(self.name)
-    cpu_report_name  = ThreadCpuTimeResultName(self.name)
-    clock_per_frame = (float(self.clock_time) / num_frames) if num_frames else 0
-    cpu_per_frame   = (float(self.cpu_time) / num_frames) if num_frames else 0
-    results.Add(clock_report_name, 'ms', clock_per_frame)
-    results.Add(cpu_report_name, 'ms', cpu_per_frame)
+    cpu_per_frame = (float(self.cpu_time) / num_frames) if num_frames else 0
+    results.Add(ThreadCpuTimeResultName(self.name), 'ms', cpu_per_frame)
 
   def AddDetailedResults(self, num_frames, results):
     slices_by_category = collections.defaultdict(list)
     for s in self.all_slices:
       slices_by_category[s.category].append(s)
     all_self_times = []
     for category, slices_in_category in slices_by_category.iteritems():
       self_time = sum([x.self_time for x in slices_in_category])
       all_self_times.append(self_time)
       self_time_result = (float(self_time) / num_frames) if num_frames else 0
       results.Add(ThreadDetailResultName(self.name, category),
                   'ms', self_time_result)
     all_measured_time = sum(all_self_times)
     all_action_time = sum([action.bounds for action in self.action_ranges])
     idle_time = max(0, all_action_time - all_measured_time)
     idle_time_result = (float(idle_time) / num_frames) if num_frames else 0
     results.Add(ThreadDetailResultName(self.name, "idle"),
                 'ms', idle_time_result)
 
 
 class ThreadTimesTimelineMetric(TimelineMetric):
   def __init__(self):
     super(ThreadTimesTimelineMetric, self).__init__(TRACING_MODE)
-    self.results_to_report = AllThreads
-    self.details_to_report = NoThreads
+    # Minimal traces, for minimum noise in CPU-time measurements.
+    self.trace_categories = MINIMAL_TRACE_CATEGORIES
+    self._results_to_report = AllThreads
+    self._details_to_report = NoThreads
+
+  @property
+  def results_to_report(self):
+    return self._results_to_report
+
+  @results_to_report.setter
+  def results_to_report(self, results_to_report):
+    self._results_to_report = results_to_report
+
+  @property
+  def details_to_report(self):
+    return self._details_to_report
+
+  @details_to_report.setter
+  def details_to_report(self, details_to_report):
+    self._details_to_report = details_to_report
+    # We need the other traces in order to have any details to report.
+    if not details_to_report == NoThreads:
+      self.trace_categories = DEFAULT_TRACE_CATEGORIES
 
   def CountSlices(self, slices, substring):
     count = 0
     for event in slices:
       if substring in event.name:
         count += 1
     return count
 
   def AddResults(self, tab, results):
     # We need at least one action or we won't count any slices.
@@ skipping 19 matching lines @@
     for thread in self._model.GetAllThreads():
       if ThreadCategoryName(thread.name) in FastPathThreads:
         thread_category_results['total_fast_path'].AppendThreadSlices(thread)
 
     # Calculate the number of frames.
     frame_slices = thread_category_results[FrameTraceThreadName].all_slices
     num_frames = self.CountSlices(frame_slices, FrameTraceName)
 
     # Report the desired results and details.
     for thread_results in thread_category_results.values():
-      if thread_results.name in self.results_to_report:
+      if thread_results.name in self._results_to_report:
         thread_results.AddResults(num_frames, results)
       # TOOD(nduca): When generic results objects are done, this special case
       # can be replaced with a generic UI feature.
-      if thread_results.name in self.details_to_report:
+      if thread_results.name in self._details_to_report:
         thread_results.AddDetailedResults(num_frames, results)