[Oilpan] Measure time for forced/idle GC

tools/perf/measurements/oilpan_gc_times.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 os
 
 from measurements import smoothness_controller
 from measurements import timeline_controller
+from telemetry import benchmark
 from telemetry.core.platform import tracing_category_filter
 from telemetry.core.platform import tracing_options
 from telemetry.page import page_test
 from telemetry.page.actions import action_runner
+from telemetry.results import results_options
 from telemetry.timeline.model import TimelineModel
 from telemetry.util import statistics
 from telemetry.value import list_of_scalar_values
 from telemetry.value import scalar
 from telemetry.value import trace
 
 
 _CR_RENDERER_MAIN = 'CrRendererMain'
 _RUN_SMOOTH_ACTIONS = 'RunSmoothAllActions'
 _NAMES_TO_DUMP = ['oilpan_precise_mark',
                   'oilpan_precise_lazy_sweep',
                   'oilpan_precise_complete_sweep',
                   'oilpan_conservative_mark',
                   'oilpan_conservative_lazy_sweep',
                   'oilpan_conservative_complete_sweep',
                   'oilpan_coalesce']
 
-def _AddTracingResults(events, results):
+def _AddTracingResults(events, include_forced_gc, results):
   # Prepare
   values = {}
   for name in _NAMES_TO_DUMP:
     values[name] = []
 
   # Parse in time line
   gc_type = None
   forced = False
   mark_time = 0
   lazy_sweep_time = 0
   complete_sweep_time = 0
   for event in events:
     duration = event.thread_duration or event.duration
     if event.name == 'ThreadHeap::coalesce':
       values['oilpan_coalesce'].append(duration)
       continue
     if event.name == 'Heap::collectGarbage':
-      if not gc_type is None and not forced:
+      if not gc_type is None and (not forced or include_forced_gc):
         values['oilpan_%s_mark' % gc_type].append(mark_time)
         values['oilpan_%s_lazy_sweep' % gc_type].append(lazy_sweep_time)
         values['oilpan_%s_complete_sweep' % gc_type].append(complete_sweep_time)
 
       gc_type = 'precise' if event.args['precise'] else 'conservative'
       forced = event.args['forced']
       mark_time = duration
       lazy_sweep_time = 0
       complete_sweep_time = 0
       continue
     if event.name == 'ThreadHeap::lazySweepPages':
       lazy_sweep_time += duration
       continue
     if event.name == 'ThreadState::completeSweep':
       complete_sweep_time += duration
       continue
 
-  if not gc_type is None and not forced:
+  if not gc_type is None and (not forced or include_forced_gc):
     values['oilpan_%s_mark' % gc_type].append(mark_time)
     values['oilpan_%s_lazy_sweep' % gc_type].append(lazy_sweep_time)
     values['oilpan_%s_complete_sweep' % gc_type].append(complete_sweep_time)
 
   # Dump
   page = results.current_page
   unit = 'ms'
   for name in _NAMES_TO_DUMP:
     if values[name]:
       results.AddValue(list_of_scalar_values.ListOfScalarValues(
@@ skipping 22 matching lines @@
   results.AddValue(
       scalar.ScalarValue(page, 'oilpan_sweep', unit, total_sweep_time))
 
   gc_time = 0
   for key in values:
     gc_time += sum(values[key])
   results.AddValue(scalar.ScalarValue(page, 'oilpan_gc', unit, gc_time))
 
 
 class _OilpanGCTimesBase(page_test.PageTest):
-  def __init__(self, action_name = ''):
+  def __init__(self, action_name='', include_forced_gc=False):
     super(_OilpanGCTimesBase, self).__init__(action_name)
     self._timeline_model = None
+    self._include_forced_gc = include_forced_gc
 
   def WillNavigateToPage(self, page, tab):
     # FIXME: Remove webkit.console when blink.console lands in chromium and
     # the ref builds are updated. crbug.com/386847
     categories = ['webkit.console', 'blink.console', 'blink_gc']
     category_filter = tracing_category_filter.TracingCategoryFilter()
     for c in categories:
       category_filter.AddIncludedCategory(c)
     options = tracing_options.TracingOptions()
     options.enable_chrome_trace = True
     tab.browser.platform.tracing_controller.Start(options, category_filter,
                                                   timeout=1000)
 
   def DidRunActions(self, page, tab):
     timeline_data = tab.browser.platform.tracing_controller.Stop()
     self._timeline_model = TimelineModel(timeline_data)
 
   def ValidateAndMeasurePage(self, page, tab, results):
     threads = self._timeline_model.GetAllThreads()
     for thread in threads:
       if thread.name == _CR_RENDERER_MAIN:
-        _AddTracingResults(thread.all_slices, results)
+        _AddTracingResults(thread.all_slices, self._include_forced_gc, results)
 
   def CleanUpAfterPage(self, page, tab):
     if tab.browser.platform.tracing_controller.is_tracing_running:
       tab.browser.platform.tracing_controller.Stop()
 
+  def _ParseEventsForTest(self, events, include_forced_gc, options):

[Sami, 2015/03/09 16:29:52]

Instead of adding this helper here, could we follow the pattern of using
ValidateAndMeasurePage with mocked data like for example here:

https://code.google.com/p/chromium/codesearch#chromium/src/tools/perf/measure...

[peria, 2015/04/02 08:26:01]

Done.

+    options.output_dir = None
+    options.output_formats = ['none']
+    options.suppress_gtest_report = True
+    options.output_trace_tag = None
+    results = results_options.CreateResults(
+        benchmark.BenchmarkMetadata(''), options)
+    # No pages are running in this test.
+    results.WillRunPage(None)
+    _AddTracingResults(events, include_forced_gc, results)
+    return results
+
 
 class OilpanGCTimesForSmoothness(_OilpanGCTimesBase):
   def __init__(self):
     super(OilpanGCTimesForSmoothness, self).__init__('RunPageInteractions')
     self._interaction = None
 
   def WillRunActions(self, page, tab):
     runner = action_runner.ActionRunner(tab)
     self._interaction = runner.BeginInteraction(_RUN_SMOOTH_ACTIONS,
                                                 is_smooth=True)
@@ skipping 14 matching lines @@
     page.script_to_evaluate_on_commit = self._blink_perf_js
     super(OilpanGCTimesForBlinkPerf, self).WillNavigateToPage(page, tab)
 
   def DidRunActions(self, page, tab):
     tab.WaitForJavaScriptExpression('testRunner.isDone', 600)
     super(OilpanGCTimesForBlinkPerf, self).DidRunActions(page, tab)
 
 
 class OilpanGCTimesForInternals(_OilpanGCTimesBase):
   def __init__(self):
-    super(OilpanGCTimesForInternals, self).__init__()
+    super(OilpanGCTimesForInternals, self).__init__(include_forced_gc=True)
 
   @classmethod
   def CustomizeBrowserOptions(cls, options):
     # 'expose-internals-for-testing' can be enabled on content shell.
     assert 'content-shell' in options.browser_type
     options.AppendExtraBrowserArgs(['--expose-internals-for-testing',
                                     '--js-flags=--expose-gc'])