tools/perf/measurements/endure.py

   1 # Copyright 2013 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 from metrics import v8_object_stats
   6 from telemetry.page import page_measurement
   7
   8 import optparse
   9 import time
  10
  11 _V8_BYTES_COMMITTED = [
  12   'V8.MemoryNewSpaceBytesCommitted',
  13   'V8.MemoryOldPointerSpaceBytesCommitted',
  14   'V8.MemoryOldDataSpaceBytesCommitted',
  15   'V8.MemoryCodeSpaceBytesCommitted',
  16   'V8.MemoryMapSpaceBytesCommitted',
  17   'V8.MemoryCellSpaceBytesCommitted',
  18   'V8.MemoryPropertyCellSpaceBytesCommitted',
  19   'V8.MemoryLoSpaceBytesCommitted'
  20 ]
  21 _V8_BYTES_USED = [
  22   'V8.MemoryNewSpaceBytesUsed',
  23   'V8.MemoryOldPointerSpaceBytesUsed',
  24   'V8.MemoryOldDataSpaceBytesUsed',
  25   'V8.MemoryCodeSpaceBytesUsed',
  26   'V8.MemoryMapSpaceBytesUsed',
  27   'V8.MemoryCellSpaceBytesUsed',
  28   'V8.MemoryPropertyCellSpaceBytesUsed',
  29   'V8.MemoryLoSpaceBytesUsed'
  30 ]
  31 _V8_MEMORY_ALLOCATED = [
  32   'V8.OsMemoryAllocated'
  33 ]
  34
  35 class Endure(page_measurement.PageMeasurement):
  36   def __init__(self):
  37     super(Endure, self).__init__('endure')
  38     self._browser = None
  39     self._test_start_time = None
  40
  41     # Timestamp of the last memory retrieval.
  42     self._last_mem_dump = 0
  43
  44   def AddCommandLineOptions(self, parser):
  45     group = optparse.OptionGroup(parser, 'Endure options')
  46     group.add_option('--perf-stats-interval',
  47                      dest='perf_stats_interval',
  48                      default=20,
  49                      type='int',
  50                      help='Time interval between perf dumps (secs)')
  51     parser.add_option_group(group)
  52
  53   def DidStartBrowser(self, browser):
  54     # Save the browser for memory_stats.
  55     self._browser = browser
  56
  57   def CustomizeBrowserOptions(self, options):
  58     v8_object_stats.V8ObjectStatsMetric.CustomizeBrowserOptions(options)
  59
  60   def CanRunForPage(self, page):
  61     return hasattr(page, 'endure')
  62
  63   def WillRunPageRepeats(self, page, tab):
  64     """Reset the starting time for each new page."""
  65     self._test_start_time = time.time()
  66
  67     # Prefix the page name so it can be picked up by endure parser.
  68     if page.name and not page.display_name.startswith('endure_'):
  69       page.name = 'endure_' + page.name
  70
  71   def MeasurePage(self, page, tab, results):
  72     """Dump perf information if we have gone past our interval time."""
  73     now = time.time()
  74     if int(round(now - self._last_mem_dump)) > self.options.perf_stats_interval:
  75       self._last_mem_dump = now
  76       self._GetPerformanceStats(tab, results, now)
  77
  78   def _GetPerformanceStats(self, tab, results, now):
  79     """Record all memory information."""
  80     elapsed_time = int(round(now - self._test_start_time))
  81
  82     # DOM Nodes
  83     dom_stats = tab.dom_stats
  84     dom_node_count = dom_stats['node_count']
  85     self._SaveToResults(results, 'TotalDOMNodeCount_X',
  86                         'seconds', elapsed_time)
  87     self._SaveToResults(results, 'TotalDOMNodeCount_Y',
  88                         'nodes', dom_node_count)
  89
  90     # Event Listeners
  91     event_listener_count = dom_stats['event_listener_count']
  92     self._SaveToResults(results, 'EventListenerCount_X',
  93                         'seconds', elapsed_time)
  94     self._SaveToResults(results, 'EventListenerCount_Y',
  95                         'listeners', event_listener_count)
  96
  97     # Memory stats
  98     memory_stats = self._browser.memory_stats
  99     browser_vm = memory_stats['Browser'].get('VM', 0) / 1024.0
 100     self._SaveToResults(results, 'BrowserVirtualMemory_X',
 101                         'seconds', elapsed_time)
 102     self._SaveToResults(results, 'BrowserVirtualMemory_Y',
 103                         'KB', browser_vm)
 104     renderer_vm = memory_stats['Renderer'].get('VM', 0) / 1024.0
 105     self._SaveToResults(results, 'RendererVirtualMemory_X',
 106                         'seconds', elapsed_time)
 107     self._SaveToResults(results, 'RendererVirtualMemory_Y',
 108                         'KB', renderer_vm)
 109
 110     # V8 stats
 111     v8_bytes_committed = v8_object_stats.V8ObjectStatsMetric.GetV8StatsTable(
 112                             tab, _V8_BYTES_COMMITTED)
 113     v8_bytes_committed = sum(v8_bytes_committed.values()) / 1024.0
 114     self._SaveToResults(results, 'V8BytesCommitted_X',
 115                         'seconds', elapsed_time)
 116     self._SaveToResults(results, 'V8BytesCommitted_Y',
 117                         'KB', v8_bytes_committed)
 118
 119     v8_bytes_used = v8_object_stats.V8ObjectStatsMetric.GetV8StatsTable(
 120                             tab, _V8_BYTES_USED)
 121     v8_bytes_used = sum(v8_bytes_used.values()) / 1024.0
 122     self._SaveToResults(results, 'V8BytesUsed_X',
 123                         'seconds', elapsed_time)
 124     self._SaveToResults(results, 'V8BytesUsed_Y',
 125                         'KB', v8_bytes_used)
 126
 127     v8_mem_allocated = v8_object_stats.V8ObjectStatsMetric.GetV8StatsTable(
 128                             tab, _V8_MEMORY_ALLOCATED)
 129     v8_mem_allocated = sum(v8_mem_allocated.values()) / 1024.0
 130     self._SaveToResults(results, 'V8MemoryAllocated_X',
 131                         'seconds', elapsed_time)
 132     self._SaveToResults(results, 'V8MemoryAllocated_Y',
 133                         'KB', v8_mem_allocated)
 134
 135   def _SaveToResults(self, results, trace_name, units, value,
 136                      chart_name=None, data_type='default'):
 137     results.Add(trace_name, units, value, chart_name, data_type)