[Oilpan] Split sweep phase in tracing into two categories

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.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.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_sweep',
+                  'oilpan_precise_lazy_sweep',
+                  'oilpan_precise_complete_sweep',
                   'oilpan_conservative_mark',
-                  'oilpan_conservative_sweep',
+                  'oilpan_conservative_lazy_sweep',
+                  'oilpan_conservative_complete_sweep',
                   'oilpan_coalesce']
 
 def _AddTracingResults(events, results):
   # Prepare
   values = {}
   for name in _NAMES_TO_DUMP:
     values[name] = []
 
   # Parse in time line
   gc_type = None
   forced = False
   mark_time = 0
-  sweep_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:
         values['oilpan_%s_mark' % gc_type].append(mark_time)
-        values['oilpan_%s_sweep' % gc_type].append(sweep_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
-      sweep_time = 0
+      lazy_sweep_time = 0
+      complete_sweep_time = 0
       continue
-    if event.name == 'ThreadState::performPendingSweep':
-      sweep_time += duration
+    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:
     values['oilpan_%s_mark' % gc_type].append(mark_time)
-    values['oilpan_%s_sweep' % gc_type].append(sweep_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(
           page, name, unit, values[name]))
       results.AddValue(scalar.ScalarValue(
           page, name + '_max', unit, max(values[name])))
     results.AddValue(scalar.ScalarValue(
         page, name + '_total', unit, sum(values[name])))
 
-  for do_type in ['mark', 'sweep']:
-    work_time = 0
+  # Summarize marking time
+  total_mark_time = 0
+  for gc_type in ['precise', 'conservative']:
+    total_mark_time += sum(values['oilpan_%s_mark' % gc_type])
+  results.AddValue(
+      scalar.ScalarValue(page, 'oilpan_mark', unit, total_mark_time))
+
+  # Summarize sweeping time
+  total_sweep_time = 0
+  for do_type in ['lazy_sweep', 'complete_sweep']:
+    sweep_time = 0
     for gc_type in ['precise', 'conservative']:
-      work_time += sum(values['oilpan_%s_%s' % (gc_type, do_type)])
+      sweep_time += sum(values['oilpan_%s_%s' % (gc_type, do_type)])
     key = 'oilpan_%s' % do_type
-    results.AddValue(scalar.ScalarValue(page, key, unit, work_time))
+    results.AddValue(scalar.ScalarValue(page, key, unit, sweep_time))
+    total_sweep_time += sweep_time
+  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 = ''):
     super(_OilpanGCTimesBase, self).__init__(action_name)
@@ skipping 59 matching lines @@
 
 class OilpanGCTimesForInternals(_OilpanGCTimesBase):
   def __init__(self):
     super(OilpanGCTimesForInternals, self).__init__()
 
   @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')