tools/perf/benchmarks/service_worker.py

   1 # Copyright 2014 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 import collections
   6 import page_sets
   7 import re
   8
   9 from measurements import timeline_controller
  10 from metrics import speedindex
  11 from telemetry import benchmark
  12 from telemetry.core import util
  13 from telemetry.page import page_test
  14 from telemetry.timeline import async_slice as async_slice_module
  15 from telemetry.timeline import slice as slice_module
  16 from telemetry.value import scalar
  17
  18
  19 class _ServiceWorkerTimelineMetric(object):
  20   def AddResultsOfCounters(self, process, counter_regex_string, results):
  21     counter_filter = re.compile(counter_regex_string)
  22     for counter_name, counter in process.counters.iteritems():
  23       if not counter_filter.search(counter_name):
  24         continue
  25
  26       total = sum(counter.totals)
  27
  28       # Results objects cannot contain the '.' character, so remove that here.
  29       sanitized_counter_name = counter_name.replace('.', '_')
  30
  31       results.AddValue(scalar.ScalarValue(
  32           results.current_page, sanitized_counter_name, 'count', total))
  33       results.AddValue(scalar.ScalarValue(
  34           results.current_page, sanitized_counter_name + '_avg', 'count',
  35           total / float(len(counter.totals))))
  36
  37   def AddResultsOfEvents(
  38       self, process, thread_regex_string, event_regex_string, results):
  39     thread_filter = re.compile(thread_regex_string)
  40     event_filter = re.compile(event_regex_string)
  41
  42     for thread in process.threads.itervalues():
  43       thread_name = thread.name.replace('/', '_')
  44       if not thread_filter.search(thread_name):
  45         continue
  46
  47       filtered_events = []
  48       for event in thread.IterAllEvents():
  49         event_name = event.name.replace('.', '_')
  50         if event_filter.search(event_name):
  51           filtered_events.append(event)
  52
  53       async_events_by_name = collections.defaultdict(list)
  54       sync_events_by_name = collections.defaultdict(list)
  55       for event in filtered_events:
  56         if isinstance(event, async_slice_module.AsyncSlice):
  57           async_events_by_name[event.name].append(event)
  58         elif isinstance(event, slice_module.Slice):
  59           sync_events_by_name[event.name].append(event)
  60
  61       for event_name, event_group in async_events_by_name.iteritems():
  62         times = [e.duration for e in event_group]
  63         self._AddResultOfEvent(thread_name, event_name, times, results)
  64
  65       for event_name, event_group in sync_events_by_name.iteritems():
  66         times = [e.self_time for e in event_group]
  67         self._AddResultOfEvent(thread_name, event_name, times, results)
  68
  69   def _AddResultOfEvent(self, thread_name, event_name, times, results):
  70     total = sum(times)
  71     biggest_jank = max(times)
  72
  73     # Results objects cannot contain the '.' character, so remove that here.
  74     sanitized_event_name = event_name.replace('.', '_')
  75
  76     full_name = thread_name + '|' + sanitized_event_name
  77     results.AddValue(scalar.ScalarValue(
  78         results.current_page, full_name, 'ms', total))
  79     results.AddValue(scalar.ScalarValue(
  80         results.current_page, full_name + '_max', 'ms', biggest_jank))
  81     results.AddValue(scalar.ScalarValue(
  82         results.current_page, full_name + '_avg', 'ms', total / len(times)))
  83
  84
  85 class _ServiceWorkerMeasurement(page_test.PageTest):
  86   """Measure Speed Index and TRACE_EVENTs"""
  87
  88   def __init__(self, *args, **kwargs):
  89     super(_ServiceWorkerMeasurement, self).__init__(*args, **kwargs)
  90     self._timeline_controller = timeline_controller.TimelineController()
  91     self._speed_index = speedindex.SpeedIndexMetric()
  92     self._page_open_times = collections.defaultdict(int)
  93
  94   def CustomizeBrowserOptions(self, options):
  95     options.AppendExtraBrowserArgs([
  96         '--enable-experimental-web-platform-features'
  97       ])
  98
  99   def WillNavigateToPage(self, page, tab):
 100     self._timeline_controller.SetUp(page, tab)
 101     self._timeline_controller.Start(tab)
 102     self._speed_index.Start(page, tab)
 103
 104   def ValidateAndMeasurePage(self, page, tab, results):
 105     tab.WaitForDocumentReadyStateToBeComplete(40)
 106     self._timeline_controller.Stop(tab)
 107
 108     # Retrieve TRACE_EVENTs
 109     timeline_metric = _ServiceWorkerTimelineMetric()
 110     browser_process = self._timeline_controller.model.browser_process
 111     filter_text = '(RegisterServiceWorker|'\
 112                   'UnregisterServiceWorker|'\
 113                   'ProcessAllocate|'\
 114                   'FindRegistrationForDocument|'\
 115                   'DispatchFetchEvent)'
 116     timeline_metric.AddResultsOfEvents(
 117         browser_process, 'IOThread', filter_text , results)
 118
 119     # Record Speed Index
 120     def SpeedIndexIsFinished():
 121       return self._speed_index.IsFinished(tab)
 122     util.WaitFor(SpeedIndexIsFinished, 60)
 123     self._speed_index.Stop(page, tab)
 124     # Distinguish the first and second load from the subsequent loads
 125     url = str(page)
 126     chart_prefix = 'page_load'
 127     self._page_open_times[url] += 1
 128     if self._page_open_times[url] == 1:
 129       chart_prefix += '_1st'
 130     elif self._page_open_times[url] == 2:
 131       chart_prefix += '_2nd'
 132     else:
 133       chart_prefix += '_later'
 134     self._speed_index.AddResults(tab, results, chart_prefix)
 135
 136
 137 class _ServiceWorkerMicroBenchmarkMeasurement(page_test.PageTest):
 138   """Measure JS land values and TRACE_EVENTs"""
 139
 140   def __init__(self, *args, **kwargs):
 141     super(_ServiceWorkerMicroBenchmarkMeasurement, self).__init__(*args,
 142                                                                   **kwargs)
 143     self._timeline_controller = timeline_controller.TimelineController()
 144
 145   def CustomizeBrowserOptions(self, options):
 146     options.AppendExtraBrowserArgs([
 147         '--enable-experimental-web-platform-features'
 148       ])
 149
 150   def WillNavigateToPage(self, page, tab):
 151     self._timeline_controller.SetUp(page, tab)
 152     self._timeline_controller.Start(tab)
 153
 154   def ValidateAndMeasurePage(self, page, tab, results):
 155     tab.WaitForJavaScriptExpression('window.done', 40)
 156     self._timeline_controller.Stop(tab)
 157
 158     # Measure JavaScript-land
 159     json = tab.EvaluateJavaScript('window.results || {}')
 160     for key, value in json.iteritems():
 161       results.AddValue(scalar.ScalarValue(
 162           results.current_page, key, value['units'], value['value']))
 163
 164     # Retrieve TRACE_EVENTs
 165     timeline_metric = _ServiceWorkerTimelineMetric()
 166     browser_process = self._timeline_controller.model.browser_process
 167     filter_text = '(RegisterServiceWorker|'\
 168                   'UnregisterServiceWorker|'\
 169                   'ProcessAllocate|'\
 170                   'FindRegistrationForDocument|'\
 171                   'DispatchFetchEvent)'
 172     timeline_metric.AddResultsOfEvents(
 173         browser_process, 'IOThread', filter_text , results)
 174
 175
 176 # TODO(simonhatch): Temporarily disabling (http://crbug.com/433943)
 177 @benchmark.Disabled
 178 class ServiceWorkerPerfTest(benchmark.Benchmark):
 179   """Performance test on public applications using ServiceWorker"""
 180   test = _ServiceWorkerMeasurement
 181   page_set = page_sets.ServiceWorkerPageSet
 182
 183
 184 # FIXME(nhiroki): Temporary disable the benchmark (http://crbug.com/430232).
 185 @benchmark.Disabled
 186 class ServiceWorkerMicroBenchmarkPerfTest(benchmark.Benchmark):
 187   """Service Worker performance test using a micro benchmark page set"""
 188   test = _ServiceWorkerMicroBenchmarkMeasurement
 189   page_set = page_sets.ServiceWorkerMicroBenchmarkPageSet