src/tools/perf/measurements/page_cycler.py

   1 # Copyright 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 """The page cycler measurement.
   6
   7 This measurement registers a window load handler in which is forces a layout and
   8 then records the value of performance.now(). This call to now() measures the
   9 time from navigationStart (immediately after the previous page's beforeunload
  10 event) until after the layout in the page's load event. In addition, two garbage
  11 collections are performed in between the page loads (in the beforeunload event).
  12 This extra garbage collection time is not included in the measurement times.
  13
  14 Finally, various memory and IO statistics are gathered at the very end of
  15 cycling all pages.
  16 """
  17
  18 import collections
  19 import os
  20
  21 from metrics import cpu
  22 from metrics import iometric
  23 from metrics import memory
  24 from metrics import power
  25 from metrics import speedindex
  26 from metrics import v8_object_stats
  27 from telemetry.core import util
  28 from telemetry.page import page_test
  29 from telemetry.value import scalar
  30
  31
  32 class PageCycler(page_test.PageTest):
  33   options = {'pageset_repeat': 10}
  34
  35   def __init__(self, *args, **kwargs):
  36     super(PageCycler, self).__init__(*args, **kwargs)
  37
  38     with open(os.path.join(os.path.dirname(__file__),
  39                            'page_cycler.js'), 'r') as f:
  40       self._page_cycler_js = f.read()
  41
  42     self._speedindex_metric = speedindex.SpeedIndexMetric()
  43     self._memory_metric = None
  44     self._power_metric = None
  45     self._cpu_metric = None
  46     self._v8_object_stats_metric = None
  47     self._has_loaded_page = collections.defaultdict(int)
  48     self._initial_renderer_url = None  # to avoid cross-renderer navigation
  49
  50   @classmethod
  51   def AddCommandLineArgs(cls, parser):
  52     parser.add_option('--v8-object-stats',
  53         action='store_true',
  54         help='Enable detailed V8 object statistics.')
  55
  56     parser.add_option('--report-speed-index',
  57         action='store_true',
  58         help='Enable the speed index metric.')
  59
  60     parser.add_option('--cold-load-percent', type='int', default=50,
  61                       help='%d of page visits for which a cold load is forced')
  62
  63   @classmethod
  64   def ProcessCommandLineArgs(cls, parser, args):
  65     cls._record_v8_object_stats = args.v8_object_stats
  66     cls._report_speed_index = args.report_speed_index
  67
  68     cold_runs_percent_set = (args.cold_load_percent != None)
  69     # Handle requests for cold cache runs
  70     if (cold_runs_percent_set and
  71         (args.cold_load_percent < 0 or args.cold_load_percent > 100)):
  72       raise Exception('--cold-load-percent must be in the range [0-100]')
  73
  74     # Make sure _cold_run_start_index is an integer multiple of page_repeat.
  75     # Without this, --pageset_shuffle + --page_repeat could lead to
  76     # assertion failures on _started_warm in WillNavigateToPage.
  77     if cold_runs_percent_set:
  78       number_warm_pageset_runs = int(
  79           (int(args.pageset_repeat) - 1) * (100 - args.cold_load_percent) / 100)
  80       number_warm_runs = number_warm_pageset_runs * args.page_repeat
  81       cls._cold_run_start_index = number_warm_runs + args.page_repeat
  82       cls.discard_first_result = (not args.cold_load_percent or
  83                                   cls.discard_first_result)
  84     else:
  85       cls._cold_run_start_index = args.pageset_repeat * args.page_repeat
  86
  87   def WillStartBrowser(self, platform):
  88     """Initialize metrics once right before the browser has been launched."""
  89     self._power_metric = power.PowerMetric(platform)
  90
  91   def DidStartBrowser(self, browser):
  92     """Initialize metrics once right after the browser has been launched."""
  93     self._memory_metric = memory.MemoryMetric(browser)
  94     self._cpu_metric = cpu.CpuMetric(browser)
  95     if self._record_v8_object_stats:
  96       self._v8_object_stats_metric = v8_object_stats.V8ObjectStatsMetric()
  97
  98   def WillNavigateToPage(self, page, tab):
  99     if page.is_file:
 100       # For legacy page cyclers which use the filesystem, do an initial
 101       # navigate to avoid paying for a cross-renderer navigation.
 102       initial_url = tab.browser.http_server.UrlOf('nonexistent.html')
 103       if self._initial_renderer_url != initial_url:
 104         self._initial_renderer_url = initial_url
 105         tab.Navigate(self._initial_renderer_url)
 106
 107     page.script_to_evaluate_on_commit = self._page_cycler_js
 108     if self.ShouldRunCold(page.url):
 109       tab.ClearCache(force=True)
 110     if self._report_speed_index:
 111       self._speedindex_metric.Start(page, tab)
 112     self._cpu_metric.Start(page, tab)
 113     self._power_metric.Start(page, tab)
 114
 115   def DidNavigateToPage(self, page, tab):
 116     self._memory_metric.Start(page, tab)
 117     if self._record_v8_object_stats:
 118       self._v8_object_stats_metric.Start(page, tab)
 119
 120   def CustomizeBrowserOptions(self, options):
 121     memory.MemoryMetric.CustomizeBrowserOptions(options)
 122     power.PowerMetric.CustomizeBrowserOptions(options)
 123     iometric.IOMetric.CustomizeBrowserOptions(options)
 124     options.AppendExtraBrowserArgs('--js-flags=--expose_gc')
 125
 126     if self._record_v8_object_stats:
 127       v8_object_stats.V8ObjectStatsMetric.CustomizeBrowserOptions(options)
 128     if self._report_speed_index:
 129       self._speedindex_metric.CustomizeBrowserOptions(options)
 130
 131   def ValidateAndMeasurePage(self, page, tab, results):
 132     tab.WaitForJavaScriptExpression('__pc_load_time', 60)
 133
 134     chart_name_prefix = ('cold_' if self.IsRunCold(page.url) else
 135                          'warm_')
 136
 137     results.AddValue(scalar.ScalarValue(
 138         results.current_page, '%stimes.page_load_time' % chart_name_prefix,
 139         'ms', tab.EvaluateJavaScript('__pc_load_time'),
 140         description='Average page load time. Measured from '
 141                     'performance.timing.navigationStart until the completion '
 142                     'time of a layout after the window.load event. Cold times '
 143                     'are the times when the page is loaded cold, i.e. without '
 144                     'loading it before, and warm times are times when the '
 145                     'page is loaded after being loaded previously.'))
 146
 147     self._has_loaded_page[page.url] += 1
 148
 149     self._power_metric.Stop(page, tab)
 150     self._memory_metric.Stop(page, tab)
 151     self._memory_metric.AddResults(tab, results)
 152     self._power_metric.AddResults(tab, results)
 153
 154     self._cpu_metric.Stop(page, tab)
 155     self._cpu_metric.AddResults(tab, results)
 156     if self._record_v8_object_stats:
 157       self._v8_object_stats_metric.Stop(page, tab)
 158       self._v8_object_stats_metric.AddResults(tab, results)
 159
 160     if self._report_speed_index:
 161       def SpeedIndexIsFinished():
 162         return self._speedindex_metric.IsFinished(tab)
 163       util.WaitFor(SpeedIndexIsFinished, 60)
 164       self._speedindex_metric.Stop(page, tab)
 165       self._speedindex_metric.AddResults(
 166           tab, results, chart_name=chart_name_prefix+'speed_index')
 167
 168   def DidRunTest(self, browser, results):
 169     iometric.IOMetric().AddSummaryResults(browser, results)
 170
 171   def IsRunCold(self, url):
 172     return (self.ShouldRunCold(url) or
 173             self._has_loaded_page[url] == 0)
 174
 175   def ShouldRunCold(self, url):
 176     # We do the warm runs first for two reasons.  The first is so we can
 177     # preserve any initial profile cache for as long as possible.
 178     # The second is that, if we did cold runs first, we'd have a transition
 179     # page set during which we wanted the run for each URL to both
 180     # contribute to the cold data and warm the catch for the following
 181     # warm run, and clearing the cache before the load of the following
 182     # URL would eliminate the intended warmup for the previous URL.
 183     return (self._has_loaded_page[url] >= self._cold_run_start_index)