Home | History | Annotate | Download | only in power_Resume 
      1 # Copyright (c) 2010 The Chromium OS 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 autotest_lib.client.bin import test
      6 from autotest_lib.client.common_lib import error
      7 from autotest_lib.client.cros.power import power_suspend
      8 
      9 
     10 # In cases like crosbug.com/p/26289, we want results, but also want
     11 # to make sure we are suspending quickly enough. Retry with this amount
     12 # of extra suspend time to make sure we can get some results, even
     13 # if we throw a warning.
     14 EXTRA_TIME = 10
     15 
     16 
     17 class power_Resume(test.test):
     18     """class for power_Resume test."""
     19     version = 1
     20     preserve_srcdir = True
     21 
     22     def initialize(self, suspend_state=''):
     23         """
     24         Entry point.
     25 
     26         @param suspend_state: Force to suspend to a specific
     27                 state ("mem" or "freeze"). If the string is empty, suspend
     28                 state is left to the default pref on the system.
     29         """
     30         self._suspender = power_suspend.Suspender(
     31                 self.resultsdir,
     32                 throw=True,
     33                 device_times=True,
     34                 suspend_state=suspend_state)
     35 
     36 
     37     def run_once(self, max_devs_returned=10, seconds=0,
     38                  ignore_kernel_warns=False, measure_arc=False):
     39         try:
     40             self._suspend_once(max_devs_returned, seconds, ignore_kernel_warns,
     41                                measure_arc)
     42         except error.TestWarn:
     43             self._suspend_once(max_devs_returned, seconds + EXTRA_TIME,
     44                                ignore_kernel_warns, measure_arc)
     45             raise
     46 
     47 
     48     def _suspend_once(self, max_devs_returned, seconds, ignore_kernel_warns,
     49                       measure_arc=False):
     50         (results, device_times) = \
     51             self._suspender.suspend(seconds,
     52                                     ignore_kernel_warns=ignore_kernel_warns,
     53                                     measure_arc=measure_arc)
     54 
     55         # return as keyvals the slowest n devices
     56         slowest_devs = sorted(
     57             device_times,
     58             key=device_times.get,
     59             reverse=True)[:max_devs_returned]
     60         for dev in slowest_devs:
     61             results[dev] = device_times[dev]
     62 
     63         self.output_perf_value(description='system_suspend',
     64                                value=results['seconds_system_suspend'],
     65                                units='sec', higher_is_better=False)
     66         self.output_perf_value(description='system_resume',
     67                                value=results['seconds_system_resume'],
     68                                units='sec', higher_is_better=False)
     69         self.write_perf_keyval(results)
     70