// SPDX-License-Identifier: GPL-2.0 /* * CPUFreq governor based on scheduler-provided CPU utilization data. * * Copyright (C) 2016, Intel Corporation * Author: Rafael J. Wysocki <[email protected]> */ #define IOWAIT_BOOST_MIN … struct sugov_tunables { … }; struct sugov_policy { … }; struct sugov_cpu { … }; static DEFINE_PER_CPU(struct sugov_cpu, sugov_cpu); /************************ Governor internals ***********************/ static bool sugov_should_update_freq(struct sugov_policy *sg_policy, u64 time) { … } static bool sugov_update_next_freq(struct sugov_policy *sg_policy, u64 time, unsigned int next_freq) { … } static void sugov_deferred_update(struct sugov_policy *sg_policy) { … } /** * get_capacity_ref_freq - get the reference frequency that has been used to * correlate frequency and compute capacity for a given cpufreq policy. We use * the CPU managing it for the arch_scale_freq_ref() call in the function. * @policy: the cpufreq policy of the CPU in question. * * Return: the reference CPU frequency to compute a capacity. */ static __always_inline unsigned long get_capacity_ref_freq(struct cpufreq_policy *policy) { … } /** * get_next_freq - Compute a new frequency for a given cpufreq policy. * @sg_policy: schedutil policy object to compute the new frequency for. * @util: Current CPU utilization. * @max: CPU capacity. * * If the utilization is frequency-invariant, choose the new frequency to be * proportional to it, that is * * next_freq = C * max_freq * util / max * * Otherwise, approximate the would-be frequency-invariant utilization by * util_raw * (curr_freq / max_freq) which leads to * * next_freq = C * curr_freq * util_raw / max * * Take C = 1.25 for the frequency tipping point at (util / max) = 0.8. * * The lowest driver-supported frequency which is equal or greater than the raw * next_freq (as calculated above) is returned, subject to policy min/max and * cpufreq driver limitations. */ static unsigned int get_next_freq(struct sugov_policy *sg_policy, unsigned long util, unsigned long max) { … } unsigned long sugov_effective_cpu_perf(int cpu, unsigned long actual, unsigned long min, unsigned long max) { … } static void sugov_get_util(struct sugov_cpu *sg_cpu, unsigned long boost) { … } /** * sugov_iowait_reset() - Reset the IO boost status of a CPU. * @sg_cpu: the sugov data for the CPU to boost * @time: the update time from the caller * @set_iowait_boost: true if an IO boost has been requested * * The IO wait boost of a task is disabled after a tick since the last update * of a CPU. If a new IO wait boost is requested after more then a tick, then * we enable the boost starting from IOWAIT_BOOST_MIN, which improves energy * efficiency by ignoring sporadic wakeups from IO. */ static bool sugov_iowait_reset(struct sugov_cpu *sg_cpu, u64 time, bool set_iowait_boost) { … } /** * sugov_iowait_boost() - Updates the IO boost status of a CPU. * @sg_cpu: the sugov data for the CPU to boost * @time: the update time from the caller * @flags: SCHED_CPUFREQ_IOWAIT if the task is waking up after an IO wait * * Each time a task wakes up after an IO operation, the CPU utilization can be * boosted to a certain utilization which doubles at each "frequent and * successive" wakeup from IO, ranging from IOWAIT_BOOST_MIN to the utilization * of the maximum OPP. * * To keep doubling, an IO boost has to be requested at least once per tick, * otherwise we restart from the utilization of the minimum OPP. */ static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, u64 time, unsigned int flags) { … } /** * sugov_iowait_apply() - Apply the IO boost to a CPU. * @sg_cpu: the sugov data for the cpu to boost * @time: the update time from the caller * @max_cap: the max CPU capacity * * A CPU running a task which woken up after an IO operation can have its * utilization boosted to speed up the completion of those IO operations. * The IO boost value is increased each time a task wakes up from IO, in * sugov_iowait_apply(), and it's instead decreased by this function, * each time an increase has not been requested (!iowait_boost_pending). * * A CPU which also appears to have been idle for at least one tick has also * its IO boost utilization reset. * * This mechanism is designed to boost high frequently IO waiting tasks, while * being more conservative on tasks which does sporadic IO operations. */ static unsigned long sugov_iowait_apply(struct sugov_cpu *sg_cpu, u64 time, unsigned long max_cap) { … } #ifdef CONFIG_NO_HZ_COMMON static bool sugov_cpu_is_busy(struct sugov_cpu *sg_cpu) { … } #else static inline bool sugov_cpu_is_busy(struct sugov_cpu *sg_cpu) { return false; } #endif /* CONFIG_NO_HZ_COMMON */ /* * Make sugov_should_update_freq() ignore the rate limit when DL * has increased the utilization. */ static inline void ignore_dl_rate_limit(struct sugov_cpu *sg_cpu) { … } static inline bool sugov_update_single_common(struct sugov_cpu *sg_cpu, u64 time, unsigned long max_cap, unsigned int flags) { … } static void sugov_update_single_freq(struct update_util_data *hook, u64 time, unsigned int flags) { … } static void sugov_update_single_perf(struct update_util_data *hook, u64 time, unsigned int flags) { … } static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu, u64 time) { … } static void sugov_update_shared(struct update_util_data *hook, u64 time, unsigned int flags) { … } static void sugov_work(struct kthread_work *work) { … } static void sugov_irq_work(struct irq_work *irq_work) { … } /************************** sysfs interface ************************/ static struct sugov_tunables *global_tunables; static DEFINE_MUTEX(global_tunables_lock); static inline struct sugov_tunables *to_sugov_tunables(struct gov_attr_set *attr_set) { … } static ssize_t rate_limit_us_show(struct gov_attr_set *attr_set, char *buf) { … } static ssize_t rate_limit_us_store(struct gov_attr_set *attr_set, const char *buf, size_t count) { … } static struct governor_attr rate_limit_us = …; static struct attribute *sugov_attrs[] = …; ATTRIBUTE_GROUPS(…); static void sugov_tunables_free(struct kobject *kobj) { … } static const struct kobj_type sugov_tunables_ktype = …; /********************** cpufreq governor interface *********************/ #ifdef CONFIG_ENERGY_MODEL static void rebuild_sd_workfn(struct work_struct *work) { … } static DECLARE_WORK(rebuild_sd_work, rebuild_sd_workfn); /* * EAS shouldn't be attempted without sugov, so rebuild the sched_domains * on governor changes to make sure the scheduler knows about it. */ static void sugov_eas_rebuild_sd(void) { … } #else static inline void sugov_eas_rebuild_sd(void) { }; #endif struct cpufreq_governor schedutil_gov; static struct sugov_policy *sugov_policy_alloc(struct cpufreq_policy *policy) { … } static void sugov_policy_free(struct sugov_policy *sg_policy) { … } static int sugov_kthread_create(struct sugov_policy *sg_policy) { … } static void sugov_kthread_stop(struct sugov_policy *sg_policy) { … } static struct sugov_tunables *sugov_tunables_alloc(struct sugov_policy *sg_policy) { … } static void sugov_clear_global_tunables(void) { … } static int sugov_init(struct cpufreq_policy *policy) { … } static void sugov_exit(struct cpufreq_policy *policy) { … } static int sugov_start(struct cpufreq_policy *policy) { … } static void sugov_stop(struct cpufreq_policy *policy) { … } static void sugov_limits(struct cpufreq_policy *policy) { … } struct cpufreq_governor schedutil_gov = …; #ifdef CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL struct cpufreq_governor *cpufreq_default_governor(void) { … } #endif cpufreq_governor_init(schedutil_gov);
Codebase Browser
linux