| # Copyright (c) 2011 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 glob, logging, os, tempfile, threading, time |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.common_lib import error, utils |
| |
| class PlatformDescriptor(object): |
| ''' |
| An object to keep platform specific information. |
| |
| @num_cores - number of CPU cores in this platform |
| @max_cpu_freq - maximum frequency the CPU can be running at |
| @min_cpu_freq - minimal frequency the CPU can be running at |
| ''' |
| |
| def __init__(self, num_cores, max_cpu_freq, min_cpu_freq): |
| self.num_cores = num_cores |
| self.max_cpu_freq = max_cpu_freq |
| self.min_cpu_freq = min_cpu_freq |
| |
| |
| # Base name of the sysfs file where CPU temperature is reported. The file is |
| # exported by the temperature monitor driver and is located in the appropriate |
| # device's subtree. We use the file name to locate the subtree, only one file |
| # with this name is expected to exist in /sys. The ext_ prefix indicates that |
| # this is a reading off a sensor located next to the CPU. This facility could |
| # be not available on some platforms, the test would need to be updated to |
| # accommodate those. |
| # |
| # The `standard' temperature reading available through |
| # /sys/class/hwmon/hwmon0/device/temperature does not represent the actual CPU |
| # temperature and when the CPU load changes, the 'standard' temperature |
| # reading changes much slower and not to such a large extent than the value in |
| # */ext_temperature. |
| EXT_TEMP_SENSOR_FILE = 'ext_temperature' |
| |
| # Base name of the file where the throttling temperature is set (if CPU temp |
| # exceeds this value, clock throttling starts). |
| THROTTLE_EXT_LIMIT_FILE = 'throttle_ext_limit' |
| |
| # Root directory for all sysfs information about the CPU(s). |
| CPU_INFO_ROOT = '/sys/devices/system/cpu' |
| |
| # Template to get access to the directory/file containing current per core |
| # information. |
| PER_CORE_FREQ_TEMPLATE = CPU_INFO_ROOT + '/cpu%d/cpufreq/%s' |
| |
| # Base name for the temporary files used by this test. |
| TMP_FILE_TEMPLATE = '/tmp/thermal_' |
| |
| # Temperature difference expected to be caused by increased CPU activity. |
| DELTA = 3.0 |
| |
| # Name of the file controlling core's clocking discipline. |
| GOVERNOR = 'scaling_governor' |
| |
| # Name of the file providing space separated list of available clocking |
| # disciplines. |
| AVAILABLE_GOVERNORS = 'scaling_available_governors' |
| |
| def clean_up(obj): |
| ''' |
| A function to register with the autotest engine to ensure proper cleanup. |
| |
| It will be called after the test has run, either completing successfully |
| or throwing an exception. |
| ''' |
| |
| obj.cleanup() |
| |
| |
| class power_Thermal(test.test): |
| version = 1 |
| |
| |
| def _cpu_heater(self): |
| ''' |
| A function to execute some code to heat up the target. |
| |
| This function is run on a separate thread, all it does - opens a file |
| for writing, writes it with 100K characters, closes and removes the |
| file, it is running in a tight loop until the stop_all_workers flag |
| turns True. |
| |
| Multiple threads are spawn to cause maximum CPU activity. |
| ''' |
| |
| (handle, fname) = tempfile.mkstemp( |
| prefix=os.path.basename(TMP_FILE_TEMPLATE), |
| dir=os.path.dirname(TMP_FILE_TEMPLATE)) |
| os.close(handle) |
| os.remove(fname) |
| while not self.stop_all_workers: |
| f = open(fname, 'w') |
| f.write('x' * 100000) |
| f.close() |
| os.remove(fname) |
| |
| |
| def _add_heater_thread(self): |
| '''Add a thread to run another instance of _cpu_heater().''' |
| |
| thread_count = len(self.worker_threads) |
| logging.info('adding thread number %d' % thread_count) |
| new_thread = threading.Thread(target=self._cpu_heater) |
| self.worker_threads.append(new_thread) |
| new_thread.daemon = True |
| new_thread.start() |
| |
| |
| def _throttle_count(self): |
| ''' |
| Return current throttling status of all cores. |
| |
| The return integer value is the sum of all cores' throttling status. |
| When the sum is equal the core number - all cores are throttling. |
| ''' |
| |
| count = 0 |
| for cpu in range(self.pl_desc.num_cores): |
| count += int(utils.read_file( |
| PER_CORE_FREQ_TEMPLATE % (cpu, 'throttle'))) |
| return count |
| |
| |
| def _cpu_freq(self, cpu): |
| '''Return current clock frequency of a CPU, integer in Kilohertz.''' |
| |
| return int(utils.read_file( |
| PER_CORE_FREQ_TEMPLATE % (cpu, 'cpuinfo_cur_freq'))) |
| |
| |
| def _cpu_temp(self): |
| '''Return current CPU temperature, a float value.''' |
| |
| return float(utils.read_file( |
| os.path.join(self.temperature_data_path, EXT_TEMP_SENSOR_FILE))) |
| |
| |
| def _throttle_limit(self): |
| ''' |
| Return current CPU throttling temperature threshold. |
| |
| If CPU temperature exceeds this value, clock throttling is activated, |
| causing CPU slowdown. |
| |
| Returns the limit as a float value. |
| ''' |
| |
| return float(utils.read_file( |
| os.path.join(self.temperature_data_path, |
| THROTTLE_EXT_LIMIT_FILE))) |
| |
| |
| def _set_throttle_limit(self, new_limit): |
| ''' |
| Set current CPU throttling temperature threshold. |
| |
| The passed in float value is rounded to the nearest integer. |
| ''' |
| |
| utils.open_write_close( |
| os.path.join( |
| self.temperature_data_path, THROTTLE_EXT_LIMIT_FILE), |
| '%d' % int(round(new_limit))) |
| |
| |
| def _check_freq(self): |
| '''Verify that all CPU clocks are in range for this target.''' |
| |
| for cpu in range(self.pl_desc.num_cores): |
| freq = self._cpu_freq(cpu) |
| if self.pl_desc.min_cpu_freq <= freq <= self.pl_desc.max_cpu_freq: |
| return |
| raise error.TestError('Wrong cpu %d frequency reading %d' % ( |
| cpu, freq)) |
| |
| |
| def _get_cpu_freq_raised(self): |
| ''' |
| Bring all cores clock to max frequency. |
| |
| This function uses the scaling_governor mechanism to force the cores |
| to run at maximum frequency, writing the string 'performance' into |
| each core's governor file. |
| |
| The current value (if not 'performance') is preserved to be restored |
| in the end of the test. |
| |
| Returns a dictionary where keys are the core numbers and values are |
| the preserved governor setting. |
| |
| raises TestError in case 'performance' setting is not allowed on any |
| of the cores, or the clock frequency does not reach max on any |
| of the cores in 1 second. |
| ''' |
| |
| rv = {} |
| for cpu in range(self.pl_desc.num_cores): |
| target = 'performance' |
| gov_file = PER_CORE_FREQ_TEMPLATE % (cpu, GOVERNOR) |
| current_gov = utils.read_file(gov_file).strip() |
| available_govs = utils.read_file(PER_CORE_FREQ_TEMPLATE % ( |
| cpu, AVAILABLE_GOVERNORS)).split() |
| |
| if current_gov != target: |
| if not target in available_govs: |
| raise error.TestError('core %d does not allow setting %s' |
| % (cpu, target)) |
| logging.info('changing core %d governor from %s to %s' % ( |
| cpu, current_gov, target)) |
| utils.open_write_close(gov_file, target) |
| rv[cpu] = current_gov |
| |
| for _ in range(2): # Wait for no more than 1 second |
| for cpu in range(self.pl_desc.num_cores): |
| if self._cpu_freq(cpu) != self.pl_desc.max_cpu_freq: |
| break |
| else: |
| return rv |
| |
| freqs = [] |
| for cpu in range(self.pl_desc.num_cores): |
| freqs.append('%d' % self._cpu_freq(cpu)) |
| raise error.TestError('failed to speed up some CPU clocks: %s' % |
| ', '.join(freqs)) |
| |
| |
| def _get_cpu_temp_raised(self): |
| ''' |
| Start more threads to increase CPU temperature. |
| |
| This function starts 10 threads and waits till either of the two |
| events happen: |
| |
| - the throttling is activated (the threshold is expected to be set at |
| DELTA/2 above the temperature when the test started). This is |
| considered a success, the function returns. |
| |
| - the temperature raises DELTA degrees above the original temperature |
| but throttling does not start. This is considered an overheating |
| failure, a test error is raised. |
| |
| If the temperature does not reach the DELTA and throttling does not |
| start in 30 seconds - a test error is also raised in this case. |
| ''' |
| |
| base_temp = self._cpu_temp() |
| # Start 10 more cpu heater threads |
| for _ in range(10): |
| self._add_heater_thread() |
| |
| # Wait 30 seconds for the temp to raise DELTA degrees or throttling to |
| # start |
| for count in range(30): |
| new_temp = self._cpu_temp() |
| if new_temp - base_temp >= DELTA: |
| raise error.TestError( |
| 'Reached temperature of %2.1fC in %d' |
| ' seconds, no throttling.' |
| % count) |
| if self._throttle_count() == self.pl_desc.num_cores: |
| logging.info('full throttle after %d seconds' % count) |
| return |
| time.sleep(1) |
| raise error.TestError( |
| 'failed to raise CPU temperature from %s (reached %s), ' |
| '%d cores throttled' % ( |
| str(base_temp), str(new_temp), self._throttle_count())) |
| |
| def _get_platform_descriptor(self): |
| '''Fill out the platform descriptor to be used by the test.''' |
| |
| present = utils.read_file(os.path.join(CPU_INFO_ROOT, 'present')) |
| if present.count('-') != 1: |
| raise error.TestError( |
| "can't determine number of cores from %s" % present) |
| (min_core, max_core) = tuple(int(x) for x in present.split('-')) |
| min_freq = int(utils.read_file( |
| PER_CORE_FREQ_TEMPLATE % (0, 'cpuinfo_min_freq'))) |
| max_freq = int(utils.read_file( |
| PER_CORE_FREQ_TEMPLATE % (0, 'cpuinfo_max_freq'))) |
| |
| return PlatformDescriptor(max_core - min_core + 1, max_freq, min_freq) |
| |
| |
| def _prepare_test(self): |
| '''Prepare test: check initial conditions and set variables.''' |
| |
| ext_temp_path = utils.system_output( |
| 'find /sys -name %s' % EXT_TEMP_SENSOR_FILE).splitlines() |
| if len(ext_temp_path) != 1: |
| raise error.TestError('found %d sensor files' % len(ext_temp_path)) |
| |
| self.temperature_data_path = os.path.dirname(ext_temp_path[0]) |
| |
| self.stop_all_workers = False |
| |
| self.pl_desc = self._get_platform_descriptor() |
| |
| # Verify CPU frequency is in range. |
| self._check_freq() |
| |
| # Make sure we are not yet throttling. |
| if self._throttle_count(): |
| raise error.TestError('Throttling active before test started') |
| |
| # Remember throttling level setting before test started. |
| self.preserved_throttle_limit = self._throttle_limit() |
| |
| if self.preserved_throttle_limit - self._cpu_temp() < 4 * DELTA: |
| raise error.TestError('Target is too hot: %s C' % str( |
| self._cpu_temp())) |
| |
| # list to keep track of threads started to heat up CPU. |
| self.worker_threads = [] |
| |
| # Dictionary of saved cores' scaling governor settings. |
| self.saved_governors = {} |
| |
| self.register_after_iteration_hook(clean_up) |
| |
| |
| def run_once(self): |
| self._prepare_test() |
| logging.info('starting temperature is %s' % str(self._cpu_temp())) |
| logging.info('starting frequency is %s' % str(self._cpu_freq(0))) |
| |
| self.saved_governors = self._get_cpu_freq_raised() |
| self._set_throttle_limit(self._cpu_temp() + DELTA/2) |
| self._get_cpu_temp_raised() |
| self._set_throttle_limit(self.preserved_throttle_limit) |
| |
| # Half a second after restoring the throttling limit is plenty for |
| # throttling to stop. |
| time.sleep(.5) |
| if self._throttle_count(): |
| raise error.TestError('Throttling did not stop') |
| |
| logging.info('ending temperature is %s' % str(self._cpu_temp())) |
| logging.info('ending frequency is %s' % str(self._cpu_freq(0))) |
| |
| |
| def cleanup(self): |
| self.stop_all_workers = True |
| self._set_throttle_limit(self.preserved_throttle_limit) |
| logging.info('stopping %d thread(s)' % len(self.worker_threads)) |
| runaway_threads = 0 |
| while self.worker_threads: |
| t = self.worker_threads.pop() |
| t.join(.5) |
| if t.isAlive(): |
| runaway_threads += 1 |
| if runaway_threads: |
| for f in glob.glob('%s*' % TMP_FILE_TEMPLATE): |
| logging.info('removing %s' % f) |
| os.remove(f) |
| raise error.TestError( |
| 'Failed to join %d worker thread(s)' % runaway_threads) |
| |
| if not self.saved_governors: |
| return |
| |
| for (cpu, gov) in self.saved_governors.iteritems(): |
| gov_file = PER_CORE_FREQ_TEMPLATE % (cpu, GOVERNOR) |
| logging.info('restoring core %d governor to %s' % (cpu, gov)) |
| utils.open_write_close(gov_file, gov) |
| self.saved_governors = {} |
