site_tests/power_Thermal/power_Thermal.py

# 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 = {}