| # Copyright (c) 2010 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, time |
| from autotest_lib.client.bin import test |
| from autotest_lib.client.common_lib import error |
| |
| # choosing a (very) conservative threshold for now to help catch |
| # major breakages |
| percent_idle_time_threshold = 20 |
| |
| class power_CPUIdle(test.test): |
| version = 1 |
| |
| def run_once(self, sleep_time=5): |
| all_cpus = cpus() |
| |
| idle_time_at_start, active_time_at_start = all_cpus.idle_time() |
| logging.info('idle_time_at_start: %d' % idle_time_at_start) |
| logging.info('active_time_at_start: %d' % active_time_at_start) |
| |
| # sleep for some time to allow the CPUs to drop into idle states |
| time.sleep(sleep_time) |
| |
| idle_time_at_end, active_time_at_end = all_cpus.idle_time() |
| logging.info('idle_time_at_end: %d' % idle_time_at_end) |
| logging.info('active_time_at_end: %d' % idle_time_at_end) |
| |
| idle_time_delta_ms = (idle_time_at_end - idle_time_at_start) / 1000 |
| logging.info('idle_time_delta_ms: %d' % idle_time_delta_ms) |
| |
| active_time_delta_ms = (active_time_at_end - active_time_at_start) \ |
| / 1000 |
| logging.info('active_time_delta_ms: %d' % active_time_delta_ms) |
| |
| total_time_delta_ms = active_time_delta_ms + idle_time_delta_ms |
| logging.info('total_time_delta_ms: %d' % total_time_delta_ms) |
| |
| percent_active_time = active_time_delta_ms * 100.0 / total_time_delta_ms |
| logging.info('percent active time : %.2f' % percent_active_time) |
| |
| percent_idle_time = idle_time_delta_ms * 100.0 / total_time_delta_ms |
| logging.info('percent idle time : %.2f' % percent_idle_time) |
| |
| keyvals = {} |
| keyvals['ms_active_time_delta'] = active_time_delta_ms |
| keyvals['ms_idle_time_delta'] = idle_time_delta_ms |
| keyvals['percent_active_time'] = percent_active_time |
| keyvals['percent_idle_time'] = percent_idle_time |
| self.write_perf_keyval(keyvals) |
| |
| if percent_idle_time < percent_idle_time_threshold: |
| raise error.TestFail('Idle percent below threshold') |
| |
| |
| |
| class cpus(object): |
| def __init__(self): |
| self.__base_path = '/sys/devices/system/cpu/cpu*/cpuidle' |
| self.__cpus = [] |
| |
| dirs = glob.glob(self.__base_path) |
| if not dirs: |
| raise error.TestError('cpuidle not supported') |
| |
| for dir in dirs: |
| cpu = cpuidle(dir) |
| self.__cpus.append(cpu) |
| |
| |
| def idle_time(self): |
| total_idle_time = 0 |
| total_active_time = 0 |
| for cpu in self.__cpus: |
| idle_time, active_time = cpu.idle_time() |
| total_idle_time += idle_time |
| total_active_time += active_time |
| return total_idle_time, total_active_time |
| |
| |
| |
| class cpuidle(object): |
| def __init__(self, path): |
| self.__base_path = path |
| self.__states = [] |
| |
| dirs = glob.glob(os.path.join(self.__base_path, 'state*')) |
| if not dirs: |
| raise error.TestError('cpuidle states missing') |
| |
| for dir in dirs: |
| state = cpuidle_state(dir) |
| self.__states.append(state) |
| |
| |
| def idle_time(self): |
| total_idle_time = 0 |
| total_active_time = 0 |
| for state in self.__states: |
| total_idle_time += state.idle_time() |
| total_active_time += state.active_time() |
| |
| return total_idle_time, total_active_time |
| |
| |
| |
| class cpuidle_state(object): |
| def __init__(self, path): |
| self.__base_path = path |
| self.__name = self.__read_file('name').split()[0] |
| self.__latency = int(self.__read_file('latency').split()[0]) |
| |
| |
| def __read_file(self, file_name): |
| path = os.path.join(self.__base_path, file_name) |
| f = open(path, 'r') |
| data = f.read() |
| f.close() |
| return data |
| |
| |
| def __is_idle_state(self): |
| if self.__latency: |
| # non-zero latency indicates non-C0 state |
| return True |
| return False |
| |
| |
| def idle_time(self): |
| time = 0 |
| if self.__is_idle_state(): |
| time = int(self.__read_file('time')) |
| logging.info('idle_time(%s): %d' % (self.__name, time)) |
| return time |
| |
| |
| def active_time(self): |
| time = 0 |
| if not self.__is_idle_state(): |
| time = int(self.__read_file('time')) |
| logging.info('active_time(%s): %d' % (self.__name, time)) |
| return time |