| # Copyright (c) 2012 The Chromium OS 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 logging |
| import os |
| import time |
| import urllib |
| |
| from autotest_lib.client.bin import test, utils |
| from autotest_lib.client.common_lib import error |
| from autotest_lib.client.common_lib.cros import chrome |
| from autotest_lib.client.cros import backchannel |
| from autotest_lib.client.cros import httpd |
| from autotest_lib.client.cros import service_stopper |
| from autotest_lib.client.cros.graphics import graphics_utils |
| from autotest_lib.client.cros.networking import wifi_proxy |
| from autotest_lib.client.cros.power import power_rapl, power_status, power_utils |
| |
| |
| class power_Consumption(test.test): |
| """Measure power consumption for different types of loads. |
| |
| This test runs a series of different tasks like media playback, flash |
| animation, large file download etc. It measures and reports power |
| consumptions during each of those tasks. |
| """ |
| |
| version = 2 |
| |
| |
| def initialize(self, ac_ok=False): |
| """Initialize test. |
| |
| Args: |
| ac_ok: boolean to allow running on AC |
| """ |
| # Objects that need to be taken care of in cleanup() are initialized |
| # here to None. Otherwise we run the risk of AttributeError raised in |
| # cleanup() masking a real error that caused the test to fail during |
| # initialize() before those variables were assigned. |
| self._backlight = None |
| self._tmp_keyvals = {} |
| |
| self._services = service_stopper.ServiceStopper( |
| service_stopper.ServiceStopper.POWER_DRAW_SERVICES) |
| self._services.stop_services() |
| |
| |
| # Time to exclude from calculation after firing a task [seconds] |
| self._stabilization_seconds = 5 |
| self._power_status = power_status.get_status() |
| self._tmp_keyvals['b_on_ac'] = self._power_status.on_ac() |
| |
| if not ac_ok: |
| # Verify that we are running on battery and the battery is |
| # sufficiently charged |
| self._power_status.assert_battery_state(30) |
| |
| # Local data and web server settings. Tarballs with traditional names |
| # like *.tgz don't get copied to the image by ebuilds (see |
| # AUTOTEST_FILE_MASK in autotest-chrome ebuild). |
| self._static_sub_dir = 'static_sites' |
| utils.extract_tarball_to_dir( |
| 'static_sites.tgz.keep', |
| os.path.join(self.bindir, self._static_sub_dir)) |
| self._media_dir = '/home/chronos/user/Downloads/' |
| self._httpd_port = 8000 |
| self._url_base = 'http://localhost:%s/' % self._httpd_port |
| self._test_server = httpd.HTTPListener(self._httpd_port, |
| docroot=self.bindir) |
| |
| # initialize various interesting power related stats |
| self._statomatic = power_status.StatoMatic() |
| self._test_server.run() |
| |
| |
| logging.info('initialize() finished') |
| |
| |
| def _download_test_data(self): |
| """Download audio and video files. |
| |
| This is also used as payload for download test. |
| |
| Note, can reach payload via browser at |
| https://console.developers.google.com/storage/chromeos-test-public/big_buck_bunny |
| Start with README |
| """ |
| |
| repo = 'http://commondatastorage.googleapis.com/chromeos-test-public/' |
| file_list = [repo + 'big_buck_bunny/big_buck_bunny_trailer_400p.mp4', ] |
| if not self.short: |
| file_list += [ |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_400p.ogg', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_400p.vp8.webm', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_400p.vp9.webm', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_720p.mp4', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_720p.ogg', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_720p.vp8.webm', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_720p.vp9.webm', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_1080p.mp4', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_1080p.ogg', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_1080p.vp8.webm', |
| repo + 'big_buck_bunny/big_buck_bunny_trailer_1080p.vp9.webm', |
| repo + 'wikimedia/Greensleeves.ogg', |
| ] |
| |
| for url in file_list: |
| logging.info('Downloading %s', url) |
| utils.unmap_url('', url, self._media_dir) |
| |
| |
| def _toggle_fullscreen(self): |
| """Toggle full screen mode.""" |
| # Note: full screen mode toggled with F11 is different from clicking the |
| # full screen icon on video player controls. This needs improvement. |
| # Bug: http://crbug.com/248939 |
| graphics_utils.screen_toggle_fullscreen() |
| |
| |
| # Below are a series of generic sub-test runners. They run a given task |
| # and record the task name and start-end timestamps for future computation |
| # of power consumption during the task. |
| def _run_func(self, name, func, repeat=1, save_checkpoint=True): |
| """Run a given python function as a sub-test.""" |
| start_time = time.time() + self._stabilization_seconds |
| for _ in xrange(repeat): |
| ret = func() |
| if save_checkpoint: |
| self._plog.checkpoint(name, start_time) |
| return ret |
| |
| |
| def _run_sleep(self, name, seconds=60): |
| """Just sleep and record it as a named sub-test""" |
| start_time = time.time() + self._stabilization_seconds |
| time.sleep(seconds) |
| self._plog.checkpoint(name, start_time) |
| |
| |
| def _run_cmd(self, name, cmd, repeat=1): |
| """Run command in a shell as a sub-test""" |
| start_time = time.time() + self._stabilization_seconds |
| for _ in xrange(repeat): |
| logging.info('Executing command: %s', cmd) |
| exit_status = utils.system(cmd, ignore_status=True) |
| if exit_status != 0: |
| logging.error('run_cmd: the following command terminated with' |
| 'a non zero exit status: %s', cmd) |
| self._plog.checkpoint(name, start_time) |
| return exit_status |
| |
| |
| def _run_until(self, name, predicate, timeout=60): |
| """Probe the |predicate| function and wait until it returns true. |
| Record the waiting time as a sub-test |
| """ |
| start_time = time.time() + self._stabilization_seconds |
| utils.poll_for_condition(predicate, timeout=timeout) |
| self._plog.checkpoint(name, start_time) |
| |
| |
| def _run_url(self, name, url, duration): |
| """Navigate to URL, sleep for some time and record it as a sub-test.""" |
| logging.info('Navigating to %s', url) |
| self._tab.Activate() |
| self._tab.Navigate(url) |
| self._run_sleep(name, duration) |
| tab_title = self._tab.EvaluateJavaScript('document.title') |
| logging.info('Sub-test name: %s Tab title: %s.', name, tab_title) |
| |
| |
| def _run_url_bg(self, name, url, duration): |
| """Run a web site in background tab. |
| |
| Navigate to the given URL, open an empty tab to put the one with the |
| URL in background, then sleep and record it as a sub-test. |
| |
| Args: |
| name: sub-test name. |
| url: url to open in background tab. |
| duration: number of seconds to sleep while taking measurements. |
| """ |
| bg_tab = self._tab |
| bg_tab.Navigate(url) |
| # Let it load and settle |
| time.sleep(self._stabilization_seconds / 2.) |
| tab_title = bg_tab.EvaluateJavaScript('document.title') |
| logging.info('App name: %s Tab title: %s.', name, tab_title) |
| # Open a new empty tab to cover the one with test payload. |
| fg_tab = self._browser.tabs.New() |
| fg_tab.Activate() |
| self._run_sleep(name, duration) |
| fg_tab.Close() |
| bg_tab.Activate() |
| |
| |
| def _run_group_download(self): |
| """Download over ethernet. Using video test data as payload.""" |
| |
| # For short run, the payload is too small to take measurement |
| self._run_func('download_eth', |
| self._download_test_data , |
| repeat=self._repeats, |
| save_checkpoint=not(self.short)) |
| |
| |
| def _run_group_webpages(self): |
| """Runs a series of web pages as sub-tests.""" |
| data_url = self._url_base + self._static_sub_dir + '/' |
| |
| # URLs to be only tested in foreground tab. |
| # Can't use about:blank here - crbug.com/248945 |
| # but chrome://version is just as good for our needs. |
| urls = [('ChromeVer', 'chrome://version/')] |
| # URLs to be tested in both, background and foreground modes. |
| bg_urls = [] |
| |
| more_urls = [('BallsDHTML', |
| data_url + 'balls/DHTMLBalls/dhtml.htm'), |
| ('BallsFlex', |
| data_url + 'balls/FlexBalls/flexballs.html'), |
| ] |
| |
| if self.short: |
| urls += more_urls |
| else: |
| bg_urls += more_urls |
| bg_urls += [('Parapluesch', |
| 'http://www.parapluesch.de/whiskystore/test.htm'), |
| ('PosterCircle', |
| 'http://www.webkit.org' |
| '/blog-files/3d-transforms/poster-circle.html'), ] |
| |
| for name, url in urls + bg_urls: |
| self._run_url(name, url, duration=self._duration_secs) |
| |
| for name, url in bg_urls: |
| self._run_url_bg('bg_' + name, url, duration=self._duration_secs) |
| |
| |
| def _run_group_speedometer(self): |
| """Run the Speedometer benchmark suite as a sub-test. |
| |
| Fire it up and wait until it displays "Score". |
| """ |
| |
| # TODO: check in a local copy of the test if we can get permission if |
| # the network causes problems. |
| url = 'http://browserbench.org/Speedometer/' |
| start_js = 'startTest()' |
| score_js = "document.getElementById('result-number').innerText" |
| tab = self._tab |
| |
| def speedometer_func(): |
| """To be passed as the callable to self._run_func()""" |
| tab.Navigate(url) |
| tab.WaitForDocumentReadyStateToBeComplete() |
| tab.EvaluateJavaScript(start_js) |
| # Speedometer test should be done in less than 15 minutes (actual |
| # runs are closer to 5). |
| is_done = lambda: tab.EvaluateJavaScript(score_js) != "" |
| time.sleep(self._stabilization_seconds) |
| utils.poll_for_condition(is_done, timeout=900, |
| desc='Speedometer score found') |
| |
| self._run_func('Speedometer', speedometer_func, repeat=self._repeats) |
| |
| # Write speedometer score from the last run to log |
| score = tab.EvaluateJavaScript(score_js) |
| logging.info('Speedometer Score: %s', score) |
| |
| |
| def _run_group_video(self): |
| """Run video and audio playback in the browser.""" |
| |
| # Note: for perf keyvals, key names are defined as VARCHAR(30) in the |
| # results DB. Chars above 30 are truncated when saved to DB. |
| urls = [('vid400p_h264', 'big_buck_bunny_trailer_400p.mp4'), ] |
| fullscreen_urls = [] |
| bg_urls = [] |
| |
| if not self.short: |
| urls += [ |
| ('vid400p_ogg', 'big_buck_bunny_trailer_400p.ogg'), |
| ('vid400p_vp8', 'big_buck_bunny_trailer_400p.vp8.webm'), |
| ('vid400p_vp9', 'big_buck_bunny_trailer_400p.vp9.webm'), |
| ('vid720_h264', 'big_buck_bunny_trailer_720p.mp4'), |
| ('vid720_ogg', 'big_buck_bunny_trailer_720p.ogg'), |
| ('vid720_vp8', 'big_buck_bunny_trailer_720p.vp8.webm'), |
| ('vid720_vp9', 'big_buck_bunny_trailer_720p.vp9.webm'), |
| ('vid1080_h264', 'big_buck_bunny_trailer_1080p.mp4'), |
| ('vid1080_ogg', 'big_buck_bunny_trailer_1080p.ogg'), |
| ('vid1080_vp8', 'big_buck_bunny_trailer_1080p.vp8.webm'), |
| ('vid1080_vp9', 'big_buck_bunny_trailer_1080p.vp9.webm'), |
| ('audio', 'Greensleeves.ogg'), |
| ] |
| |
| fullscreen_urls += [ |
| ('vid720_h264_fs', 'big_buck_bunny_trailer_720p.mp4'), |
| ('vid720_vp8_fs', 'big_buck_bunny_trailer_720p.vp8.webm'), |
| ('vid720_vp9_fs', 'big_buck_bunny_trailer_720p.vp9.webm'), |
| ('vid1080_h264_fs', 'big_buck_bunny_trailer_1080p.mp4'), |
| ('vid1080_vp8_fs', 'big_buck_bunny_trailer_1080p.vp8.webm'), |
| ('vid1080_vp9_fs', 'big_buck_bunny_trailer_1080p.vp9.webm'), |
| ] |
| |
| bg_urls += [ |
| ('bg_vid400p', 'big_buck_bunny_trailer_400p.vp8.webm'), |
| ] |
| |
| # The video files are run from a file:// url. In order to work properly |
| # from an http:// url, some careful web server configuration is needed |
| def full_url(filename): |
| """Create a file:// url for the media file and verify it exists. |
| |
| @param filename: string |
| """ |
| p = os.path.join(self._media_dir, filename) |
| if not os.path.isfile(p): |
| raise error.TestError('Media file %s is missing.', p) |
| return 'file://' + p |
| |
| js_loop_enable = """ve = document.getElementsByTagName('video')[0]; |
| ve.loop = true; |
| ve.play(); |
| """ |
| |
| for name, url in urls: |
| logging.info('Playing video %s', url) |
| self._tab.Navigate(full_url(url)) |
| self._tab.ExecuteJavaScript(js_loop_enable) |
| self._run_sleep(name, self._duration_secs) |
| |
| for name, url in fullscreen_urls: |
| self._toggle_fullscreen() |
| self._tab.Navigate(full_url(url)) |
| self._tab.ExecuteJavaScript(js_loop_enable) |
| self._run_sleep(name, self._duration_secs) |
| self._toggle_fullscreen() |
| |
| for name, url in bg_urls: |
| logging.info('Playing video in background tab %s', url) |
| self._tab.Navigate(full_url(url)) |
| self._tab.ExecuteJavaScript(js_loop_enable) |
| fg_tab = self._browser.tabs.New() |
| self._run_sleep(name, self._duration_secs) |
| fg_tab.Close() |
| self._tab.Activate() |
| |
| |
| def _run_group_sound(self): |
| """Run non-UI sound test using 'speaker-test'.""" |
| # For some reason speaker-test won't work on CrOS without a reasonable |
| # buffer size specified with -b. |
| # http://crbug.com/248955 |
| cmd = 'speaker-test -l %s -t sine -c 2 -b 16384' % (self._repeats * 6) |
| self._run_cmd('speaker_test', cmd) |
| |
| |
| def _run_group_lowlevel(self): |
| """Low level system stuff""" |
| mb = min(1024, 32 * self._repeats) |
| self._run_cmd('memtester', '/usr/local/sbin/memtester %s 1' % mb) |
| |
| # one rep of dd takes about 15 seconds |
| root_dev = utils.get_root_partition() |
| cmd = 'dd if=%s of=/dev/null' % root_dev |
| self._run_cmd('dd', cmd, repeat=2 * self._repeats) |
| |
| |
| def _run_group_backchannel(self): |
| """WiFi sub-tests.""" |
| |
| shill = wifi_proxy.WifiProxy() |
| for _ in xrange(3): |
| succeeded, _, _, _, _ = shill.connect_to_wifi_network( |
| ssid='GoogleGuest', |
| security='none', |
| security_parameters={}, |
| save_credentials=False) |
| if succeeded: |
| break |
| |
| if not succeeded: |
| logging.error("Could not connect to WiFi") |
| return |
| |
| logging.info('Starting Backchannel') |
| with backchannel.Backchannel(): |
| # Wifi needs some time to recover after backchanel is activated |
| # TODO (kamrik) remove this sleep, once backchannel handles this |
| time.sleep(15) |
| |
| cmd = 'ping -c %s www.google.com' % (self._duration_secs) |
| self._run_cmd('ping_wifi', cmd) |
| |
| # This URL must be visible from WiFi network used for test |
| big_file_url = ('http://googleappengine.googlecode.com' |
| '/files/GoogleAppEngine-1.6.2.msi') |
| cmd = 'curl %s > /dev/null' % big_file_url |
| self._run_cmd('download_wifi', cmd, repeat=self._repeats) |
| |
| |
| def _run_group_backlight(self): |
| """Vary backlight brightness and record power at each setting.""" |
| for i in [100, 50, 0]: |
| self._backlight.set_percent(i) |
| start_time = time.time() + self._stabilization_seconds |
| time.sleep(30 * self._repeats) |
| self._plog.checkpoint('backlight_%03d' % i, start_time) |
| self._backlight.set_default() |
| |
| |
| def _web_echo(self, msg): |
| """ Displays a message in the browser.""" |
| url = self._url_base + 'echo.html?' |
| url += urllib.quote(msg) |
| self._tab.Navigate(url) |
| |
| |
| def _run_test_groups(self, groups): |
| """ Run all the test groups. |
| |
| Args: |
| groups: list of sub-test groups to run. Each sub-test group refers |
| to a _run_group_...() function. |
| """ |
| |
| for group in groups: |
| logging.info('Running group %s', group) |
| # The _web_echo here is important for some tests (esp. non UI) |
| # it gets the previous web page replaced with an almost empty one. |
| self._tab.Activate() |
| self._web_echo('Running test %s' % group) |
| test_func = getattr(self, '_run_group_%s' % group) |
| test_func() |
| |
| |
| def run_once(self, short=False, test_groups=None, reps=1): |
| # Some sub-tests have duration specified directly, _base_secs * reps |
| # is used in this case. Others complete whenever the underlying task |
| # completes, those are manually tuned to be roughly around |
| # reps * 30 seconds. Don't change _base_secs unless you also |
| # change the manual tuning in sub-tests |
| self._base_secs = 30 |
| self._repeats = reps |
| self._duration_secs = self._base_secs * reps |
| |
| # Lists of default tests to run |
| UI_TESTS = ['backlight', 'download', 'webpages', 'video', 'speedometer'] |
| NONUI_TESTS = ['backchannel', 'sound', 'lowlevel'] |
| DEFAULT_TESTS = UI_TESTS + NONUI_TESTS |
| DEFAULT_SHORT_TESTS = ['download', 'webpages', 'video'] |
| |
| self.short = short |
| if test_groups is None: |
| if self.short: |
| test_groups = DEFAULT_SHORT_TESTS |
| else: |
| test_groups = DEFAULT_TESTS |
| logging.info('Test groups to run: %s', ', '.join(test_groups)) |
| |
| self._backlight = power_utils.Backlight() |
| self._backlight.set_default() |
| |
| measure = [] |
| if not self._power_status.on_ac(): |
| measure += \ |
| [power_status.SystemPower(self._power_status.battery_path)] |
| if power_utils.has_powercap_support(): |
| measure += power_rapl.create_powercap() |
| elif power_utils.has_rapl_support(): |
| measure += power_rapl.create_rapl() |
| self._plog = power_status.PowerLogger(measure) |
| self._plog.start() |
| |
| # Log in. |
| with chrome.Chrome() as cr: |
| self._browser = cr.browser |
| graphics_utils.screen_disable_energy_saving() |
| # Most of the tests will be running in this tab. |
| self._tab = cr.browser.tabs[0] |
| |
| # Verify that we have a functioning browser and local web server. |
| self._tab.Activate() |
| self._web_echo("Sanity_test") |
| self._tab.WaitForDocumentReadyStateToBeComplete() |
| |
| # Video test must have the data from download test |
| if ('video' in test_groups): |
| iv = test_groups.index('video') |
| if 'download' not in test_groups[:iv]: |
| msg = '"download" test must run before "video".' |
| raise error.TestError(msg) |
| |
| # Run all the test groups |
| self._run_test_groups(test_groups) |
| |
| # Wrap up |
| keyvals = self._plog.calc() |
| keyvals.update(self._tmp_keyvals) |
| keyvals.update(self._statomatic.publish()) |
| |
| # check AC status is still the same as init |
| self._power_status.refresh() |
| on_ac = self._power_status.on_ac() |
| if keyvals['b_on_ac'] != on_ac: |
| raise error.TestError('on AC changed between start & stop of test') |
| |
| if not on_ac: |
| whrs = self._power_status.battery.energy_full_design |
| logging.info("energy_full_design = %0.3f Wh", whrs) |
| |
| # Calculate expected battery life time with ChromeVer power draw |
| idle_name = 'ChromeVer_system_pwr_avg' |
| if idle_name in keyvals: |
| hours_life = whrs / keyvals[idle_name] |
| keyvals['hours_battery_ChromeVer'] = hours_life |
| |
| # Calculate a weighted power draw and battery life time. The weights |
| # are intended to represent "typical" usage. Some video, some Flash |
| # ... and most of the time idle. see, |
| # http://www.chromium.org/chromium-os/testing/power-testing |
| weights = {'vid400p_h264_system_pwr_avg':0.1, |
| 'BallsFlex_system_pwr_avg':0.1, |
| 'BallsDHTML_system_pwr_avg':0.3, |
| } |
| weights[idle_name] = 1 - sum(weights.values()) |
| |
| if set(weights).issubset(set(keyvals)): |
| p = sum(w * keyvals[k] for (k, w) in weights.items()) |
| keyvals['w_Weighted_system_pwr_avg'] = p |
| keyvals['hours_battery_Weighted'] = whrs / p |
| |
| self.write_perf_keyval(keyvals) |
| self._plog.save_results(self.resultsdir) |
| |
| |
| def cleanup(self): |
| # cleanup() is run by common_lib/test.py |
| try: |
| self._test_server.stop() |
| except AttributeError: |
| logging.debug('test_server could not be stopped in cleanup') |
| |
| if self._backlight: |
| self._backlight.restore() |
| if self._services: |
| self._services.restore_services() |
| |
| super(power_Consumption, self).cleanup() |
