| OLD | NEW |
|---|
| (Empty) |
| 1 #!/usr/bin/env python | |
| 2 # Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 3 # Use of this source code is governed by a BSD-style license that can be | |
| 4 # found in the LICENSE file. | |
| 5 | |
| 6 """Performance tests for Chrome Endure (long-running perf tests on Chrome). | |
| 7 | |
| 8 This module accepts the following environment variable inputs: | |
| 9 TEST_LENGTH: The number of seconds in which to run each test. | |
| 10 PERF_STATS_INTERVAL: The number of seconds to wait in-between each sampling | |
| 11 of performance/memory statistics. | |
| 12 | |
| 13 The following variables are related to the Deep Memory Profiler. | |
| 14 DEEP_MEMORY_PROFILE: Enable the Deep Memory Profiler if it's set to 'True'. | |
| 15 DEEP_MEMORY_PROFILE_SAVE: Don't clean up dump files if it's set to 'True'. | |
| 16 DEEP_MEMORY_PROFILE_UPLOAD: Upload dumped files if the variable has a Google | |
| 17 Storage bucket like gs://chromium-endure/. The 'gsutil' script in $PATH | |
| 18 is used by default, or set a variable 'GSUTIL' to specify a path to the | |
| 19 'gsutil' script. A variable 'REVISION' (or 'BUILDBOT_GOT_REVISION') is | |
| 20 used as a subdirectory in the destination if it is set. | |
| 21 GSUTIL: A path to the 'gsutil' script. Not mandatory. | |
| 22 REVISION: A string that represents the revision or some build configuration. | |
| 23 Not mandatory. | |
| 24 BUILDBOT_GOT_REVISION: Similar to 'REVISION', but checked only if 'REVISION' | |
| 25 is not specified. Not mandatory. | |
| 26 """ | |
| 27 | |
| 28 from datetime import datetime | |
| 29 import json | |
| 30 import logging | |
| 31 import os | |
| 32 import re | |
| 33 import subprocess | |
| 34 import tempfile | |
| 35 import time | |
| 36 | |
| 37 import perf | |
| 38 import pyauto_functional # Must be imported before pyauto. | |
| 39 import pyauto | |
| 40 import pyauto_errors | |
| 41 import pyauto_utils | |
| 42 import remote_inspector_client | |
| 43 import selenium.common.exceptions | |
| 44 from selenium.webdriver.support.ui import WebDriverWait | |
| 45 | |
| 46 | |
| 47 class NotSupportedEnvironmentError(RuntimeError): | |
| 48 """Represent an error raised since the environment (OS) is not supported.""" | |
| 49 pass | |
| 50 | |
| 51 | |
| 52 class DeepMemoryProfiler(object): | |
| 53 """Controls Deep Memory Profiler (dmprof) for endurance tests.""" | |
| 54 DEEP_MEMORY_PROFILE = False | |
| 55 DEEP_MEMORY_PROFILE_SAVE = False | |
| 56 DEEP_MEMORY_PROFILE_UPLOAD = '' | |
| 57 | |
| 58 _WORKDIR_PATTERN = re.compile('endure\.[0-9]+\.[0-9]+\.[A-Za-z0-9]+') | |
| 59 _SAVED_WORKDIRS = 8 | |
| 60 | |
| 61 _DMPROF_DIR_PATH = os.path.abspath(os.path.join( | |
| 62 os.path.dirname(__file__), os.pardir, os.pardir, os.pardir, | |
| 63 'tools', 'deep_memory_profiler')) | |
| 64 _DMPROF_SCRIPT_PATH = os.path.join(_DMPROF_DIR_PATH, 'dmprof') | |
| 65 _POLICIES = ['l0', 'l1', 'l2', 't0'] | |
| 66 | |
| 67 def __init__(self): | |
| 68 self._enabled = self.GetEnvironmentVariable( | |
| 69 'DEEP_MEMORY_PROFILE', bool, self.DEEP_MEMORY_PROFILE) | |
| 70 self._save = self.GetEnvironmentVariable( | |
| 71 'DEEP_MEMORY_PROFILE_SAVE', bool, self.DEEP_MEMORY_PROFILE_SAVE) | |
| 72 self._upload = self.GetEnvironmentVariable( | |
| 73 'DEEP_MEMORY_PROFILE_UPLOAD', str, self.DEEP_MEMORY_PROFILE_UPLOAD) | |
| 74 if self._upload and not self._upload.endswith('/'): | |
| 75 self._upload += '/' | |
| 76 | |
| 77 self._revision = '' | |
| 78 self._gsutil = '' | |
| 79 self._json_file = None | |
| 80 self._last_json_filename = '' | |
| 81 self._proc = None | |
| 82 self._last_time = {} | |
| 83 for policy in self._POLICIES: | |
| 84 self._last_time[policy] = -1.0 | |
| 85 | |
| 86 def __nonzero__(self): | |
| 87 return self._enabled | |
| 88 | |
| 89 @staticmethod | |
| 90 def GetEnvironmentVariable(env_name, converter, default): | |
| 91 """Returns a converted environment variable for Deep Memory Profiler. | |
| 92 | |
| 93 Args: | |
| 94 env_name: A string name of an environment variable. | |
| 95 converter: A function taking a string to convert an environment variable. | |
| 96 default: A value used if the environment variable is not specified. | |
| 97 | |
| 98 Returns: | |
| 99 A value converted from the environment variable with 'converter'. | |
| 100 """ | |
| 101 return converter(os.environ.get(env_name, default)) | |
| 102 | |
| 103 def SetUp(self, is_linux, revision, gsutil): | |
| 104 """Sets up Deep Memory Profiler settings for a Chrome process. | |
| 105 | |
| 106 It sets environment variables and makes a working directory. | |
| 107 """ | |
| 108 if not self._enabled: | |
| 109 return | |
| 110 | |
| 111 if not is_linux: | |
| 112 raise NotSupportedEnvironmentError( | |
| 113 'Deep Memory Profiler is not supported in this environment (OS).') | |
| 114 | |
| 115 self._revision = revision | |
| 116 self._gsutil = gsutil | |
| 117 | |
| 118 # Remove old dumped files with keeping latest _SAVED_WORKDIRS workdirs. | |
| 119 # It keeps the latest workdirs not to miss data by failure in uploading | |
| 120 # and other operations. Dumped files are no longer available if they are | |
| 121 # removed. Re-execution doesn't generate the same files. | |
| 122 tempdir = tempfile.gettempdir() | |
| 123 saved_workdirs = 0 | |
| 124 for filename in sorted(os.listdir(tempdir), reverse=True): | |
| 125 if self._WORKDIR_PATTERN.match(filename): | |
| 126 saved_workdirs += 1 | |
| 127 if saved_workdirs > self._SAVED_WORKDIRS: | |
| 128 fullpath = os.path.abspath(os.path.join(tempdir, filename)) | |
| 129 logging.info('Removing an old workdir: %s' % fullpath) | |
| 130 pyauto_utils.RemovePath(fullpath) | |
| 131 | |
| 132 dir_prefix = 'endure.%s.' % datetime.today().strftime('%Y%m%d.%H%M%S') | |
| 133 self._workdir = tempfile.mkdtemp(prefix=dir_prefix, dir=tempdir) | |
| 134 os.environ['HEAPPROFILE'] = os.path.join(self._workdir, 'endure') | |
| 135 os.environ['HEAP_PROFILE_MMAP'] = '1' | |
| 136 os.environ['DEEP_HEAP_PROFILE'] = '1' | |
| 137 | |
| 138 def TearDown(self): | |
| 139 """Tear down Deep Memory Profiler settings for the Chrome process. | |
| 140 | |
| 141 It removes the environment variables and the temporary directory. | |
| 142 Call it after Chrome finishes. Chrome may dump last files at the end. | |
| 143 """ | |
| 144 if not self._enabled: | |
| 145 return | |
| 146 | |
| 147 del os.environ['DEEP_HEAP_PROFILE'] | |
| 148 del os.environ['HEAP_PROFILE_MMAP'] | |
| 149 del os.environ['HEAPPROFILE'] | |
| 150 if not self._save and self._workdir: | |
| 151 pyauto_utils.RemovePath(self._workdir) | |
| 152 | |
| 153 def LogFirstMessage(self): | |
| 154 """Logs first messages.""" | |
| 155 if not self._enabled: | |
| 156 return | |
| 157 | |
| 158 logging.info('Running with the Deep Memory Profiler.') | |
| 159 if self._save: | |
| 160 logging.info(' Dumped files won\'t be cleaned.') | |
| 161 else: | |
| 162 logging.info(' Dumped files will be cleaned up after every test.') | |
| 163 | |
| 164 def StartProfiler(self, proc_info, is_last, webapp_name, test_description): | |
| 165 """Starts Deep Memory Profiler in background.""" | |
| 166 if not self._enabled: | |
| 167 return | |
| 168 | |
| 169 logging.info(' Profiling with the Deep Memory Profiler...') | |
| 170 | |
| 171 # Wait for a running dmprof process for last _GetPerformanceStat call to | |
| 172 # cover last dump files. | |
| 173 if is_last: | |
| 174 logging.info(' Waiting for the last dmprof.') | |
| 175 self._WaitForDeepMemoryProfiler() | |
| 176 | |
| 177 if self._proc and self._proc.poll() is None: | |
| 178 logging.info(' Last dmprof is still running.') | |
| 179 else: | |
| 180 if self._json_file: | |
| 181 self._last_json_filename = self._json_file.name | |
| 182 self._json_file.close() | |
| 183 self._json_file = None | |
| 184 first_dump = '' | |
| 185 last_dump = '' | |
| 186 for filename in sorted(os.listdir(self._workdir)): | |
| 187 if re.match('^endure.%05d.\d+.heap$' % proc_info['tab_pid'], | |
| 188 filename): | |
| 189 logging.info(' Profiled dump file: %s' % filename) | |
| 190 last_dump = filename | |
| 191 if not first_dump: | |
| 192 first_dump = filename | |
| 193 if first_dump: | |
| 194 logging.info(' First dump file: %s' % first_dump) | |
| 195 matched = re.match('^endure.\d+.(\d+).heap$', last_dump) | |
| 196 last_sequence_id = matched.group(1) | |
| 197 self._json_file = open( | |
| 198 os.path.join(self._workdir, | |
| 199 'endure.%05d.%s.json' % (proc_info['tab_pid'], | |
| 200 last_sequence_id)), 'w+') | |
| 201 self._proc = subprocess.Popen( | |
| 202 '%s json %s' % (self._DMPROF_SCRIPT_PATH, | |
| 203 os.path.join(self._workdir, first_dump)), | |
| 204 shell=True, stdout=self._json_file) | |
| 205 if is_last: | |
| 206 # Wait only when it is the last profiling. dmprof may take long time. | |
| 207 self._WaitForDeepMemoryProfiler() | |
| 208 | |
| 209 # Upload the dumped files. | |
| 210 if first_dump and self._upload and self._gsutil: | |
| 211 if self._revision: | |
| 212 destination_path = '%s%s/' % (self._upload, self._revision) | |
| 213 else: | |
| 214 destination_path = self._upload | |
| 215 destination_path += '%s-%s-%s.zip' % ( | |
| 216 webapp_name, | |
| 217 test_description, | |
| 218 os.path.basename(self._workdir)) | |
| 219 gsutil_command = '%s upload --gsutil %s %s %s' % ( | |
| 220 self._DMPROF_SCRIPT_PATH, | |
| 221 self._gsutil, | |
| 222 os.path.join(self._workdir, first_dump), | |
| 223 destination_path) | |
| 224 logging.info('Uploading: %s' % gsutil_command) | |
| 225 try: | |
| 226 returncode = subprocess.call(gsutil_command, shell=True) | |
| 227 logging.info(' Return code: %d' % returncode) | |
| 228 except OSError, e: | |
| 229 logging.error(' Error while uploading: %s', e) | |
| 230 else: | |
| 231 logging.info('Note that the dumped files are not uploaded.') | |
| 232 else: | |
| 233 logging.info(' No dump files.') | |
| 234 | |
| 235 def ParseResultAndOutputPerfGraphValues( | |
| 236 self, webapp_name, test_description, output_perf_graph_value): | |
| 237 """Parses Deep Memory Profiler result, and outputs perf graph values.""" | |
| 238 if not self._enabled: | |
| 239 return | |
| 240 | |
| 241 results = {} | |
| 242 for policy in self._POLICIES: | |
| 243 if self._last_json_filename: | |
| 244 json_data = {} | |
| 245 with open(self._last_json_filename) as json_f: | |
| 246 json_data = json.load(json_f) | |
| 247 if json_data['version'] == 'JSON_DEEP_1': | |
| 248 results[policy] = json_data['snapshots'] | |
| 249 elif json_data['version'] == 'JSON_DEEP_2': | |
| 250 results[policy] = json_data['policies'][policy]['snapshots'] | |
| 251 for policy, result in results.iteritems(): | |
| 252 if result and result[-1]['second'] > self._last_time[policy]: | |
| 253 started = False | |
| 254 for legend in json_data['policies'][policy]['legends']: | |
| 255 if legend == 'FROM_HERE_FOR_TOTAL': | |
| 256 started = True | |
| 257 elif legend == 'UNTIL_HERE_FOR_TOTAL': | |
| 258 break | |
| 259 elif started: | |
| 260 output_perf_graph_value( | |
| 261 legend.encode('utf-8'), [ | |
| 262 (int(round(snapshot['second'])), snapshot[legend] / 1024) | |
| 263 for snapshot in result | |
| 264 if snapshot['second'] > self._last_time[policy]], | |
| 265 'KB', | |
| 266 graph_name='%s%s-%s-DMP' % ( | |
| 267 webapp_name, test_description, policy), | |
| 268 units_x='seconds', is_stacked=True) | |
| 269 self._last_time[policy] = result[-1]['second'] | |
| 270 | |
| 271 def _WaitForDeepMemoryProfiler(self): | |
| 272 """Waits for the Deep Memory Profiler to finish if running.""" | |
| 273 if not self._enabled or not self._proc: | |
| 274 return | |
| 275 | |
| 276 self._proc.wait() | |
| 277 self._proc = None | |
| 278 if self._json_file: | |
| 279 self._last_json_filename = self._json_file.name | |
| 280 self._json_file.close() | |
| 281 self._json_file = None | |
| 282 | |
| 283 | |
| 284 class ChromeEndureBaseTest(perf.BasePerfTest): | |
| 285 """Implements common functionality for all Chrome Endure tests. | |
| 286 | |
| 287 All Chrome Endure test classes should inherit from this class. | |
| 288 """ | |
| 289 | |
| 290 _DEFAULT_TEST_LENGTH_SEC = 60 * 60 * 6 # Tests run for 6 hours. | |
| 291 _GET_PERF_STATS_INTERVAL = 60 * 5 # Measure perf stats every 5 minutes. | |
| 292 # TODO(dennisjeffrey): Do we still need to tolerate errors? | |
| 293 _ERROR_COUNT_THRESHOLD = 50 # Number of errors to tolerate. | |
| 294 _REVISION = '' | |
| 295 _GSUTIL = 'gsutil' | |
| 296 | |
| 297 def setUp(self): | |
| 298 # The environment variables for the Deep Memory Profiler must be set | |
| 299 # before perf.BasePerfTest.setUp() to inherit them to Chrome. | |
| 300 self._dmprof = DeepMemoryProfiler() | |
| 301 self._revision = str(os.environ.get('REVISION', self._REVISION)) | |
| 302 if not self._revision: | |
| 303 self._revision = str(os.environ.get('BUILDBOT_GOT_REVISION', | |
| 304 self._REVISION)) | |
| 305 self._gsutil = str(os.environ.get('GSUTIL', self._GSUTIL)) | |
| 306 if self._dmprof: | |
| 307 self._dmprof.SetUp(self.IsLinux(), self._revision, self._gsutil) | |
| 308 | |
| 309 perf.BasePerfTest.setUp(self) | |
| 310 | |
| 311 self._test_length_sec = int( | |
| 312 os.environ.get('TEST_LENGTH', self._DEFAULT_TEST_LENGTH_SEC)) | |
| 313 self._get_perf_stats_interval = int( | |
| 314 os.environ.get('PERF_STATS_INTERVAL', self._GET_PERF_STATS_INTERVAL)) | |
| 315 | |
| 316 logging.info('Running test for %d seconds.', self._test_length_sec) | |
| 317 logging.info('Gathering perf stats every %d seconds.', | |
| 318 self._get_perf_stats_interval) | |
| 319 | |
| 320 if self._dmprof: | |
| 321 self._dmprof.LogFirstMessage() | |
| 322 | |
| 323 # Set up a remote inspector client associated with tab 0. | |
| 324 logging.info('Setting up connection to remote inspector...') | |
| 325 self._remote_inspector_client = ( | |
| 326 remote_inspector_client.RemoteInspectorClient()) | |
| 327 logging.info('Connection to remote inspector set up successfully.') | |
| 328 | |
| 329 self._test_start_time = 0 | |
| 330 self._num_errors = 0 | |
| 331 self._events_to_output = [] | |
| 332 | |
| 333 def tearDown(self): | |
| 334 logging.info('Terminating connection to remote inspector...') | |
| 335 self._remote_inspector_client.Stop() | |
| 336 logging.info('Connection to remote inspector terminated.') | |
| 337 | |
| 338 # Must be done at end of this function except for post-cleaning after | |
| 339 # Chrome finishes. | |
| 340 perf.BasePerfTest.tearDown(self) | |
| 341 | |
| 342 # Must be done after perf.BasePerfTest.tearDown() | |
| 343 if self._dmprof: | |
| 344 self._dmprof.TearDown() | |
| 345 | |
| 346 def ExtraChromeFlags(self): | |
| 347 """Ensures Chrome is launched with custom flags. | |
| 348 | |
| 349 Returns: | |
| 350 A list of extra flags to pass to Chrome when it is launched. | |
| 351 """ | |
| 352 # The same with setUp, but need to fetch the environment variable since | |
| 353 # ExtraChromeFlags is called before setUp. | |
| 354 deep_memory_profile = DeepMemoryProfiler.GetEnvironmentVariable( | |
| 355 'DEEP_MEMORY_PROFILE', bool, DeepMemoryProfiler.DEEP_MEMORY_PROFILE) | |
| 356 | |
| 357 # Ensure Chrome enables remote debugging on port 9222. This is required to | |
| 358 # interact with Chrome's remote inspector. | |
| 359 # Also, enable the memory benchmarking V8 extension for heap dumps. | |
| 360 extra_flags = ['--remote-debugging-port=9222', | |
| 361 '--enable-memory-benchmarking'] | |
| 362 if deep_memory_profile: | |
| 363 extra_flags.append('--no-sandbox') | |
| 364 return perf.BasePerfTest.ExtraChromeFlags(self) + extra_flags | |
| 365 | |
| 366 def _OnTimelineEvent(self, event_info): | |
| 367 """Invoked by the Remote Inspector Client when a timeline event occurs. | |
| 368 | |
| 369 Args: | |
| 370 event_info: A dictionary containing raw information associated with a | |
| 371 timeline event received from Chrome's remote inspector. Refer to | |
| 372 chrome/src/third_party/WebKit/Source/WebCore/inspector/Inspector.json | |
| 373 for the format of this dictionary. | |
| 374 """ | |
| 375 elapsed_time = int(round(time.time() - self._test_start_time)) | |
| 376 | |
| 377 if event_info['type'] == 'GCEvent': | |
| 378 self._events_to_output.append({ | |
| 379 'type': 'GarbageCollection', | |
| 380 'time': elapsed_time, | |
| 381 'data': | |
| 382 {'collected_bytes': event_info['data']['usedHeapSizeDelta']}, | |
| 383 }) | |
| 384 | |
| 385 def _RunEndureTest(self, webapp_name, tab_title_substring, test_description, | |
| 386 do_scenario, frame_xpath=''): | |
| 387 """The main test harness function to run a general Chrome Endure test. | |
| 388 | |
| 389 After a test has performed any setup work and has navigated to the proper | |
| 390 starting webpage, this function should be invoked to run the endurance test. | |
| 391 | |
| 392 Args: | |
| 393 webapp_name: A string name for the webapp being tested. Should not | |
| 394 include spaces. For example, 'Gmail', 'Docs', or 'Plus'. | |
| 395 tab_title_substring: A unique substring contained within the title of | |
| 396 the tab to use, for identifying the appropriate tab. | |
| 397 test_description: A string description of what the test does, used for | |
| 398 outputting results to be graphed. Should not contain spaces. For | |
| 399 example, 'ComposeDiscard' for Gmail. | |
| 400 do_scenario: A callable to be invoked that implements the scenario to be | |
| 401 performed by this test. The callable is invoked iteratively for the | |
| 402 duration of the test. | |
| 403 frame_xpath: The string xpath of the frame in which to inject javascript | |
| 404 to clear chromedriver's cache (a temporary workaround until the | |
| 405 WebDriver team changes how they handle their DOM node cache). | |
| 406 """ | |
| 407 self._num_errors = 0 | |
| 408 self._test_start_time = time.time() | |
| 409 last_perf_stats_time = time.time() | |
| 410 if self._dmprof: | |
| 411 self.HeapProfilerDump('renderer', 'Chrome Endure (first)') | |
| 412 self._GetPerformanceStats( | |
| 413 webapp_name, test_description, tab_title_substring) | |
| 414 self._iteration_num = 0 # Available to |do_scenario| if needed. | |
| 415 | |
| 416 self._remote_inspector_client.StartTimelineEventMonitoring( | |
| 417 self._OnTimelineEvent) | |
| 418 | |
| 419 while time.time() - self._test_start_time < self._test_length_sec: | |
| 420 self._iteration_num += 1 | |
| 421 | |
| 422 if self._num_errors >= self._ERROR_COUNT_THRESHOLD: | |
| 423 logging.error('Error count threshold (%d) reached. Terminating test ' | |
| 424 'early.' % self._ERROR_COUNT_THRESHOLD) | |
| 425 break | |
| 426 | |
| 427 if time.time() - last_perf_stats_time >= self._get_perf_stats_interval: | |
| 428 last_perf_stats_time = time.time() | |
| 429 if self._dmprof: | |
| 430 self.HeapProfilerDump('renderer', 'Chrome Endure') | |
| 431 self._GetPerformanceStats( | |
| 432 webapp_name, test_description, tab_title_substring) | |
| 433 | |
| 434 if self._iteration_num % 10 == 0: | |
| 435 remaining_time = self._test_length_sec - (time.time() - | |
| 436 self._test_start_time) | |
| 437 logging.info('Chrome interaction #%d. Time remaining in test: %d sec.' % | |
| 438 (self._iteration_num, remaining_time)) | |
| 439 | |
| 440 do_scenario() | |
| 441 # Clear ChromeDriver's DOM node cache so its growth doesn't affect the | |
| 442 # results of Chrome Endure. | |
| 443 # TODO(dennisjeffrey): Once the WebDriver team implements changes to | |
| 444 # handle their DOM node cache differently, we need to revisit this. It | |
| 445 # may no longer be necessary at that point to forcefully delete the cache. | |
| 446 # Additionally, the Javascript below relies on an internal property of | |
| 447 # WebDriver that may change at any time. This is only a temporary | |
| 448 # workaround to stabilize the Chrome Endure test results. | |
| 449 js = """ | |
| 450 (function() { | |
| 451 delete document.$wdc_; | |
| 452 window.domAutomationController.send('done'); | |
| 453 })(); | |
| 454 """ | |
| 455 try: | |
| 456 self.ExecuteJavascript(js, frame_xpath=frame_xpath) | |
| 457 except pyauto_errors.AutomationCommandTimeout: | |
| 458 self._num_errors += 1 | |
| 459 logging.warning('Logging an automation timeout: delete chromedriver ' | |
| 460 'cache.') | |
| 461 | |
| 462 self._remote_inspector_client.StopTimelineEventMonitoring() | |
| 463 | |
| 464 if self._dmprof: | |
| 465 self.HeapProfilerDump('renderer', 'Chrome Endure (last)') | |
| 466 self._GetPerformanceStats( | |
| 467 webapp_name, test_description, tab_title_substring, is_last=True) | |
| 468 | |
| 469 def _GetProcessInfo(self, tab_title_substring): | |
| 470 """Gets process info associated with an open browser/tab. | |
| 471 | |
| 472 Args: | |
| 473 tab_title_substring: A unique substring contained within the title of | |
| 474 the tab to use; needed for locating the tab info. | |
| 475 | |
| 476 Returns: | |
| 477 A dictionary containing information about the browser and specified tab | |
| 478 process: | |
| 479 { | |
| 480 'browser_private_mem': integer, # Private memory associated with the | |
| 481 # browser process, in KB. | |
| 482 'tab_private_mem': integer, # Private memory associated with the tab | |
| 483 # process, in KB. | |
| 484 'tab_pid': integer, # Process ID of the tab process. | |
| 485 } | |
| 486 """ | |
| 487 browser_process_name = ( | |
| 488 self.GetBrowserInfo()['properties']['BrowserProcessExecutableName']) | |
| 489 info = self.GetProcessInfo() | |
| 490 | |
| 491 # Get the information associated with the browser process. | |
| 492 browser_proc_info = [] | |
| 493 for browser_info in info['browsers']: | |
| 494 if browser_info['process_name'] == browser_process_name: | |
| 495 for proc_info in browser_info['processes']: | |
| 496 if proc_info['child_process_type'] == 'Browser': | |
| 497 browser_proc_info.append(proc_info) | |
| 498 self.assertEqual(len(browser_proc_info), 1, | |
| 499 msg='Expected to find 1 Chrome browser process, but found ' | |
| 500 '%d instead.\nCurrent process info:\n%s.' % ( | |
| 501 len(browser_proc_info), self.pformat(info))) | |
| 502 | |
| 503 # Get the process information associated with the specified tab. | |
| 504 tab_proc_info = [] | |
| 505 for browser_info in info['browsers']: | |
| 506 for proc_info in browser_info['processes']: | |
| 507 if (proc_info['child_process_type'] == 'Tab' and | |
| 508 [x for x in proc_info['titles'] if tab_title_substring in x]): | |
| 509 tab_proc_info.append(proc_info) | |
| 510 self.assertEqual(len(tab_proc_info), 1, | |
| 511 msg='Expected to find 1 %s tab process, but found %d ' | |
| 512 'instead.\nCurrent process info:\n%s.' % ( | |
| 513 tab_title_substring, len(tab_proc_info), | |
| 514 self.pformat(info))) | |
| 515 | |
| 516 browser_proc_info = browser_proc_info[0] | |
| 517 tab_proc_info = tab_proc_info[0] | |
| 518 return { | |
| 519 'browser_private_mem': browser_proc_info['working_set_mem']['priv'], | |
| 520 'tab_private_mem': tab_proc_info['working_set_mem']['priv'], | |
| 521 'tab_pid': tab_proc_info['pid'], | |
| 522 } | |
| 523 | |
| 524 def _GetPerformanceStats(self, webapp_name, test_description, | |
| 525 tab_title_substring, is_last=False): | |
| 526 """Gets performance statistics and outputs the results. | |
| 527 | |
| 528 Args: | |
| 529 webapp_name: A string name for the webapp being tested. Should not | |
| 530 include spaces. For example, 'Gmail', 'Docs', or 'Plus'. | |
| 531 test_description: A string description of what the test does, used for | |
| 532 outputting results to be graphed. Should not contain spaces. For | |
| 533 example, 'ComposeDiscard' for Gmail. | |
| 534 tab_title_substring: A unique substring contained within the title of | |
| 535 the tab to use, for identifying the appropriate tab. | |
| 536 is_last: A boolean value which should be True if it's the last call of | |
| 537 _GetPerformanceStats. The default is False. | |
| 538 """ | |
| 539 logging.info('Gathering performance stats...') | |
| 540 elapsed_time = int(round(time.time() - self._test_start_time)) | |
| 541 | |
| 542 memory_counts = self._remote_inspector_client.GetMemoryObjectCounts() | |
| 543 proc_info = self._GetProcessInfo(tab_title_substring) | |
| 544 | |
| 545 if self._dmprof: | |
| 546 self._dmprof.StartProfiler( | |
| 547 proc_info, is_last, webapp_name, test_description) | |
| 548 | |
| 549 # DOM node count. | |
| 550 dom_node_count = memory_counts['DOMNodeCount'] | |
| 551 self._OutputPerfGraphValue( | |
| 552 'TotalDOMNodeCount', [(elapsed_time, dom_node_count)], 'nodes', | |
| 553 graph_name='%s%s-Nodes-DOM' % (webapp_name, test_description), | |
| 554 units_x='seconds') | |
| 555 | |
| 556 # Event listener count. | |
| 557 event_listener_count = memory_counts['EventListenerCount'] | |
| 558 self._OutputPerfGraphValue( | |
| 559 'EventListenerCount', [(elapsed_time, event_listener_count)], | |
| 560 'listeners', | |
| 561 graph_name='%s%s-EventListeners' % (webapp_name, test_description), | |
| 562 units_x='seconds') | |
| 563 | |
| 564 # Browser process private memory. | |
| 565 self._OutputPerfGraphValue( | |
| 566 'BrowserPrivateMemory', | |
| 567 [(elapsed_time, proc_info['browser_private_mem'])], 'KB', | |
| 568 graph_name='%s%s-BrowserMem-Private' % (webapp_name, test_description), | |
| 569 units_x='seconds') | |
| 570 | |
| 571 # Tab process private memory. | |
| 572 self._OutputPerfGraphValue( | |
| 573 'TabPrivateMemory', | |
| 574 [(elapsed_time, proc_info['tab_private_mem'])], 'KB', | |
| 575 graph_name='%s%s-TabMem-Private' % (webapp_name, test_description), | |
| 576 units_x='seconds') | |
| 577 | |
| 578 # V8 memory used. | |
| 579 v8_info = self.GetV8HeapStats() # First window, first tab. | |
| 580 v8_mem_used = v8_info['v8_memory_used'] / 1024.0 # Convert to KB. | |
| 581 self._OutputPerfGraphValue( | |
| 582 'V8MemoryUsed', [(elapsed_time, v8_mem_used)], 'KB', | |
| 583 graph_name='%s%s-V8MemUsed' % (webapp_name, test_description), | |
| 584 units_x='seconds') | |
| 585 | |
| 586 # V8 memory allocated. | |
| 587 v8_mem_allocated = v8_info['v8_memory_allocated'] / 1024.0 # Convert to KB. | |
| 588 self._OutputPerfGraphValue( | |
| 589 'V8MemoryAllocated', [(elapsed_time, v8_mem_allocated)], 'KB', | |
| 590 graph_name='%s%s-V8MemAllocated' % (webapp_name, test_description), | |
| 591 units_x='seconds') | |
| 592 | |
| 593 if self._dmprof: | |
| 594 self._dmprof.ParseResultAndOutputPerfGraphValues( | |
| 595 webapp_name, test_description, self._OutputPerfGraphValue) | |
| 596 | |
| 597 logging.info(' Total DOM node count: %d nodes' % dom_node_count) | |
| 598 logging.info(' Event listener count: %d listeners' % event_listener_count) | |
| 599 logging.info(' Browser process private memory: %d KB' % | |
| 600 proc_info['browser_private_mem']) | |
| 601 logging.info(' Tab process private memory: %d KB' % | |
| 602 proc_info['tab_private_mem']) | |
| 603 logging.info(' V8 memory used: %f KB' % v8_mem_used) | |
| 604 logging.info(' V8 memory allocated: %f KB' % v8_mem_allocated) | |
| 605 | |
| 606 # Output any new timeline events that have occurred. | |
| 607 if self._events_to_output: | |
| 608 logging.info('Logging timeline events...') | |
| 609 event_type_to_value_list = {} | |
| 610 for event_info in self._events_to_output: | |
| 611 if not event_info['type'] in event_type_to_value_list: | |
| 612 event_type_to_value_list[event_info['type']] = [] | |
| 613 event_type_to_value_list[event_info['type']].append( | |
| 614 (event_info['time'], event_info['data'])) | |
| 615 for event_type, value_list in event_type_to_value_list.iteritems(): | |
| 616 self._OutputEventGraphValue(event_type, value_list) | |
| 617 self._events_to_output = [] | |
| 618 else: | |
| 619 logging.info('No new timeline events to log.') | |
| 620 | |
| 621 def _GetElement(self, find_by, value): | |
| 622 """Gets a WebDriver element object from the webpage DOM. | |
| 623 | |
| 624 Args: | |
| 625 find_by: A callable that queries WebDriver for an element from the DOM. | |
| 626 value: A string value that can be passed to the |find_by| callable. | |
| 627 | |
| 628 Returns: | |
| 629 The identified WebDriver element object, if found in the DOM, or | |
| 630 None, otherwise. | |
| 631 """ | |
| 632 try: | |
| 633 return find_by(value) | |
| 634 except selenium.common.exceptions.NoSuchElementException: | |
| 635 return None | |
| 636 | |
| 637 def _ClickElementByXpath(self, driver, xpath): | |
| 638 """Given the xpath for a DOM element, clicks on it using WebDriver. | |
| 639 | |
| 640 Args: | |
| 641 driver: A WebDriver object, as returned by self.NewWebDriver(). | |
| 642 xpath: The string xpath associated with the DOM element to click. | |
| 643 | |
| 644 Returns: | |
| 645 True, if the DOM element was found and clicked successfully, or | |
| 646 False, otherwise. | |
| 647 """ | |
| 648 try: | |
| 649 self.WaitForDomNode(xpath) | |
| 650 except (pyauto_errors.JSONInterfaceError, | |
| 651 pyauto_errors.JavascriptRuntimeError) as e: | |
| 652 logging.exception('PyAuto exception: %s' % e) | |
| 653 return False | |
| 654 | |
| 655 try: | |
| 656 element = self._GetElement(driver.find_element_by_xpath, xpath) | |
| 657 element.click() | |
| 658 except (selenium.common.exceptions.StaleElementReferenceException, | |
| 659 selenium.common.exceptions.TimeoutException) as e: | |
| 660 logging.exception('WebDriver exception: %s' % e) | |
| 661 return False | |
| 662 | |
| 663 return True | |
| 664 | |
| 665 | |
| 666 class ChromeEndureControlTest(ChromeEndureBaseTest): | |
| 667 """Control tests for Chrome Endure.""" | |
| 668 | |
| 669 _WEBAPP_NAME = 'Control' | |
| 670 _TAB_TITLE_SUBSTRING = 'Chrome Endure Control Test' | |
| 671 | |
| 672 def testControlAttachDetachDOMTree(self): | |
| 673 """Continually attach and detach a DOM tree from a basic document.""" | |
| 674 test_description = 'AttachDetachDOMTree' | |
| 675 url = self.GetHttpURLForDataPath('chrome_endure', 'endurance_control.html') | |
| 676 self.NavigateToURL(url) | |
| 677 loaded_tab_title = self.GetActiveTabTitle() | |
| 678 self.assertTrue(self._TAB_TITLE_SUBSTRING in loaded_tab_title, | |
| 679 msg='Loaded tab title does not contain "%s": "%s"' % | |
| 680 (self._TAB_TITLE_SUBSTRING, loaded_tab_title)) | |
| 681 | |
| 682 def scenario(): | |
| 683 # Just sleep. Javascript in the webpage itself does the work. | |
| 684 time.sleep(5) | |
| 685 | |
| 686 self._RunEndureTest(self._WEBAPP_NAME, self._TAB_TITLE_SUBSTRING, | |
| 687 test_description, scenario) | |
| 688 | |
| 689 def testControlAttachDetachDOMTreeWebDriver(self): | |
| 690 """Use WebDriver to attach and detach a DOM tree from a basic document.""" | |
| 691 test_description = 'AttachDetachDOMTreeWebDriver' | |
| 692 url = self.GetHttpURLForDataPath('chrome_endure', | |
| 693 'endurance_control_webdriver.html') | |
| 694 self.NavigateToURL(url) | |
| 695 loaded_tab_title = self.GetActiveTabTitle() | |
| 696 self.assertTrue(self._TAB_TITLE_SUBSTRING in loaded_tab_title, | |
| 697 msg='Loaded tab title does not contain "%s": "%s"' % | |
| 698 (self._TAB_TITLE_SUBSTRING, loaded_tab_title)) | |
| 699 | |
| 700 driver = self.NewWebDriver() | |
| 701 | |
| 702 def scenario(driver): | |
| 703 # Click the "attach" button to attach a large DOM tree (with event | |
| 704 # listeners) to the document, wait half a second, click "detach" to detach | |
| 705 # the DOM tree from the document, wait half a second. | |
| 706 self._ClickElementByXpath(driver, 'id("attach")') | |
| 707 time.sleep(0.5) | |
| 708 self._ClickElementByXpath(driver, 'id("detach")') | |
| 709 time.sleep(0.5) | |
| 710 | |
| 711 self._RunEndureTest(self._WEBAPP_NAME, self._TAB_TITLE_SUBSTRING, | |
| 712 test_description, lambda: scenario(driver)) | |
| 713 | |
| 714 | |
| 715 class IndexedDBOfflineTest(ChromeEndureBaseTest): | |
| 716 """Long-running performance tests for IndexedDB, modeling offline usage.""" | |
| 717 | |
| 718 _WEBAPP_NAME = 'IndexedDBOffline' | |
| 719 _TAB_TITLE_SUBSTRING = 'IndexedDB Offline' | |
| 720 | |
| 721 def setUp(self): | |
| 722 ChromeEndureBaseTest.setUp(self) | |
| 723 | |
| 724 url = self.GetHttpURLForDataPath('indexeddb', 'endure', 'app.html') | |
| 725 self.NavigateToURL(url) | |
| 726 loaded_tab_title = self.GetActiveTabTitle() | |
| 727 self.assertTrue(self._TAB_TITLE_SUBSTRING in loaded_tab_title, | |
| 728 msg='Loaded tab title does not contain "%s": "%s"' % | |
| 729 (self._TAB_TITLE_SUBSTRING, loaded_tab_title)) | |
| 730 | |
| 731 self._driver = self.NewWebDriver() | |
| 732 | |
| 733 def testOfflineOnline(self): | |
| 734 """Simulates user input while offline and sync while online. | |
| 735 | |
| 736 This test alternates between a simulated "Offline" state (where user | |
| 737 input events are queued) and an "Online" state (where user input events | |
| 738 are dequeued, sync data is staged, and sync data is unstaged). | |
| 739 """ | |
| 740 test_description = 'OnlineOfflineSync' | |
| 741 | |
| 742 def scenario(): | |
| 743 # Click the "Online" button and let simulated sync run for 1 second. | |
| 744 if not self._ClickElementByXpath(self._driver, 'id("online")'): | |
| 745 self._num_errors += 1 | |
| 746 logging.warning('Logging an automation error: click "online" button.') | |
| 747 | |
| 748 try: | |
| 749 self.WaitForDomNode('id("state")[text()="online"]') | |
| 750 except (pyauto_errors.JSONInterfaceError, | |
| 751 pyauto_errors.JavascriptRuntimeError): | |
| 752 self._num_errors += 1 | |
| 753 logging.warning('Logging an automation error: wait for "online".') | |
| 754 | |
| 755 time.sleep(1) | |
| 756 | |
| 757 # Click the "Offline" button and let user input occur for 1 second. | |
| 758 if not self._ClickElementByXpath(self._driver, 'id("offline")'): | |
| 759 self._num_errors += 1 | |
| 760 logging.warning('Logging an automation error: click "offline" button.') | |
| 761 | |
| 762 try: | |
| 763 self.WaitForDomNode('id("state")[text()="offline"]') | |
| 764 except (pyauto_errors.JSONInterfaceError, | |
| 765 pyauto_errors.JavascriptRuntimeError): | |
| 766 self._num_errors += 1 | |
| 767 logging.warning('Logging an automation error: wait for "offline".') | |
| 768 | |
| 769 time.sleep(1) | |
| 770 | |
| 771 self._RunEndureTest(self._WEBAPP_NAME, self._TAB_TITLE_SUBSTRING, | |
| 772 test_description, scenario) | |
| 773 | |
| 774 | |
| 775 if __name__ == '__main__': | |
| 776 pyauto_functional.Main() | |
| OLD | NEW |
|---|
Chromium Code Reviews
