| #!/usr/bin/python |
| # |
| # Copyright (c) 2012 The Chromium 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 subprocess |
| import time |
| |
| from autotest_lib.client.bin import test, utils |
| from autotest_lib.client.common_lib import error |
| |
| class kernel_SchedBandwith(test.test): |
| """Test kernel CFS_BANDWIDTH scheduler mechanism (/sys/fs/cgroup/...)""" |
| version = 1 |
| # A 30 second (default) run should result in most of the time slices being |
| # throttled. Set a conservative lower bound based on having an unknown |
| # system load. Alex commonly yields numbers in the range 311..315, which |
| # includes test overhead and signal latency. |
| _MIN_SECS = 30 |
| |
| _CG_DIR = "/sys/fs/cgroup/cpu" |
| _CG_CRB_DIR = os.path.join(_CG_DIR, "chrome_renderers", "background") |
| |
| def _parse_cpu_stats(self): |
| """Parse and return CFS bandwidth statistics. |
| |
| From kernel/Documentation/scheduler/sched-bwc.txt |
| |
| cpu.stat: |
| - nr_periods: Number of enforcement intervals that have elapsed. |
| - nr_throttled: Number of times the group has been throttled/limited. |
| - throttled_time: The total time duration (in nanoseconds) for which entities |
| of the group have been throttled. |
| |
| Returns: tuple with nr_periods, nr_throttled, throttled_time. |
| """ |
| nr_periods = None |
| nr_throttled = None |
| throttled_time = None |
| |
| fd = open(os.path.join(self._CG_CRB_DIR, "cpu.stat")) |
| |
| for ln in fd.readlines(): |
| logging.debug(ln) |
| (name, val) = ln.split() |
| logging.debug("name = %s val = %s", name, val) |
| if name == 'nr_periods': |
| nr_periods = int(val) |
| if name == 'nr_throttled': |
| nr_throttled = int(val) |
| if name == 'throttled_time': |
| throttled_time = int(val) |
| |
| fd.close() |
| return nr_periods, nr_throttled, throttled_time |
| |
| @staticmethod |
| def _parse_pid_stats(pid): |
| """Parse process id stats to determin CPU utilization. |
| |
| from: https://www.kernel.org/doc/Documentation/scheduler/sched-stats.txt |
| |
| /proc/<pid>/schedstat |
| ---------------- |
| schedstats also adds a new /proc/<pid>/schedstat file to include some |
| of the same information on a per-process level. There are three |
| fields in this file correlating for that process to: |
| 1) time spent on the cpu |
| 2) time spent waiting on a runqueue |
| 3) # of timeslices run on this cpu |
| |
| Args: |
| pid: integer, process id to gather stats for. |
| |
| Returns: |
| tuple with total_msecs and idle_msecs |
| """ |
| idle_slices = 0 |
| total_slices = 0 |
| |
| fname = "/proc/sys/kernel/sched_cfs_bandwidth_slice_us" |
| timeslice_ms = int(utils.read_one_line(fname).strip()) / 1000. |
| |
| with open(os.path.join('/proc', str(pid), 'schedstat')) as fd: |
| values = list(int(val) for val in fd.readline().strip().split()) |
| running_slices = values[0] / timeslice_ms |
| idle_slices = values[1] / timeslice_ms |
| total_slices = running_slices + idle_slices |
| return (total_slices, idle_slices) |
| |
| |
| def _cg_start_task(self, in_cgroup=True): |
| """Start a CPU hogging task and add to cgroup. |
| |
| Args: |
| in_cgroup: Boolean, if true add to cgroup otherwise just start. |
| |
| Returns: |
| integer of pid of task started |
| """ |
| null_fd = open("/dev/null", "w") |
| cmd = ['seq', '0', '0', '0'] |
| task = subprocess.Popen(cmd, stdout=null_fd) |
| self._tasks.append(task) |
| |
| if in_cgroup: |
| utils.write_one_line(os.path.join(self._CG_CRB_DIR, "tasks"), |
| task.pid) |
| return task.pid |
| |
| |
| def _cg_stop_tasks(self): |
| """Stop CPU hogging task.""" |
| if hasattr(self, '_tasks') and self._tasks: |
| for task in self._tasks: |
| task.kill() |
| self._tasks = [] |
| |
| |
| def _cg_set_quota(self, quota=-1): |
| """Set CPU quota that can be used for cgroup |
| |
| Default of -1 will disable throttling |
| """ |
| utils.write_one_line(os.path.join(self._CG_CRB_DIR, "cpu.cfs_quota_us"), |
| quota) |
| rd_quota = utils.read_one_line(os.path.join(self._CG_CRB_DIR, |
| "cpu.cfs_quota_us")) |
| if rd_quota != quota: |
| error.TestFail("Setting cpu quota to %d" % quota) |
| |
| |
| def _cg_total_shares(self): |
| if not hasattr(self, '_total_shares'): |
| self._total_shares = int(utils.read_one_line( |
| os.path.join(self._CG_DIR, "cpu.shares"))) |
| return self._total_shares |
| |
| |
| def _cg_set_shares(self, shares=None): |
| """Set CPU shares that can be used for cgroup |
| |
| Default of None reads total shares for cpu group and assigns that so |
| there will be no throttling |
| """ |
| if shares is None: |
| shares = self._cg_total_shares() |
| utils.write_one_line(os.path.join(self._CG_CRB_DIR, "cpu.shares"), |
| shares) |
| rd_shares = utils.read_one_line(os.path.join(self._CG_CRB_DIR, |
| "cpu.shares")) |
| if rd_shares != shares: |
| error.TestFail("Setting cpu shares to %d" % shares) |
| |
| |
| def _cg_disable_throttling(self): |
| self._cg_set_quota() |
| self._cg_set_shares() |
| |
| |
| def _cg_test_quota(self): |
| stats = [] |
| period_us = int(utils.read_one_line(os.path.join(self._CG_CRB_DIR, |
| "cpu.cfs_period_us"))) |
| |
| stats.append(self._parse_cpu_stats()) |
| |
| self._cg_start_task() |
| self._cg_set_quota(int(period_us * 0.1)) |
| time.sleep(self._MIN_SECS) |
| |
| stats.append(self._parse_cpu_stats()) |
| |
| self._cg_stop_tasks() |
| return stats |
| |
| |
| def _cg_test_shares(self): |
| stats = [] |
| |
| self._cg_set_shares(2) |
| pid = self._cg_start_task() |
| stats.append(self._parse_pid_stats(pid)) |
| |
| # load system heavily |
| for _ in xrange(utils.count_cpus() * 2 + 1): |
| self._cg_start_task(in_cgroup=False) |
| |
| time.sleep(self._MIN_SECS) |
| |
| stats.append(self._parse_pid_stats(pid)) |
| |
| self._cg_stop_tasks() |
| return stats |
| |
| |
| @staticmethod |
| def _check_stats(name, stats, percent): |
| total = stats[1][0] - stats[0][0] |
| idle = stats[1][1] - stats[0][1] |
| logging.info("%s total:%d idle:%d", |
| name, total, idle) |
| |
| # make sure we idled at least X% of the slices |
| min_idle = int(percent * total) |
| if idle < min_idle: |
| logging.error("%s idle count %d < %d ", name, idle, |
| min_idle) |
| return 1 |
| return 0 |
| |
| |
| def setup(self): |
| super(kernel_SchedBandwith, self).setup() |
| self._tasks = [] |
| self._quota = None |
| self._shares = None |
| |
| |
| def run_once(self, test_quota=True, test_shares=True): |
| errors = 0 |
| if not os.path.exists(self._CG_CRB_DIR): |
| raise error.TestError("Locating cgroup dir %s" % self._CG_CRB_DIR) |
| |
| self._quota = utils.read_one_line(os.path.join(self._CG_CRB_DIR, |
| "cpu.cfs_quota_us")) |
| self._shares = utils.read_one_line(os.path.join(self._CG_CRB_DIR, |
| "cpu.shares")) |
| if test_quota: |
| self._cg_disable_throttling() |
| quota_stats = self._cg_test_quota() |
| errors += self._check_stats('quota', quota_stats, 0.9) |
| |
| if test_shares: |
| self._cg_disable_throttling() |
| shares_stats = self._cg_test_shares() |
| errors += self._check_stats('shares', shares_stats, 0.6) |
| |
| if errors: |
| error.TestFail("Cgroup bandwidth throttling not working") |
| |
| |
| def cleanup(self): |
| super(kernel_SchedBandwith, self).cleanup() |
| self._cg_stop_tasks() |
| |
| if hasattr(self, '_quota') and self._quota is not None: |
| self._cg_set_quota(self._quota) |
| |
| if hasattr(self, '_shares') and self._shares is not None: |
| self._cg_set_shares(self._shares) |
