litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Linus Torvalds <torvalds@linux-foundation.org>	2008-08-27 17:31:44 -0400
committer	Linus Torvalds <torvalds@linux-foundation.org>	2008-08-27 17:31:44 -0400
commit	5b51a7e9d84f19df4d532ebf5624dbb8ad0d6c9c (patch)
tree	aa8359921a8039474c7bb1544823184855e59694 /drivers/net/3c59x.c
parent	3d87ff3e44bd2a13cbe2d2e02cc5e38953ff260f (diff)
parent	4cdfe84b51420c9ac95c7133da2d4c8a191094af (diff)

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6: [PATCH] deal with the first call of ->show() generating no output [PATCH] fix ->llseek() for a bunch of directories [PATCH] fix regular readdir() and friends [PATCH] fix hpux_getdents() [PATCH] fix osf_getdirents() [PATCH] ntfs: use d_add_ci [PATCH] change d_add_ci argument ordering [PATCH] fix efs_lookup() [PATCH] proc: inode number fixlet

Diffstat (limited to 'drivers/net/3c59x.c')

0 files changed, 0 insertions, 0 deletions

/* * CPUFreq governor based on scheduler-provided CPU utilization data. * * Copyright (C) 2016, Intel Corporation * Author: Rafael J. Wysocki <rafael.j.wysocki@intel.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/cpufreq.h> #include <linux/slab.h> #include <trace/events/power.h> #include "sched.h" struct sugov_tunables { struct gov_attr_set attr_set; unsigned int rate_limit_us; }; struct sugov_policy { struct cpufreq_policy *policy; struct sugov_tunables *tunables; struct list_head tunables_hook; raw_spinlock_t update_lock; /* For shared policies */ u64 last_freq_update_time; s64 freq_update_delay_ns; unsigned int next_freq; /* The next fields are only needed if fast switch cannot be used. */ struct irq_work irq_work; struct work_struct work; struct mutex work_lock; bool work_in_progress; bool need_freq_update; }; struct sugov_cpu { struct update_util_data update_util; struct sugov_policy *sg_policy; unsigned int cached_raw_freq; unsigned long iowait_boost; unsigned long iowait_boost_max; u64 last_update; /* The fields below are only needed when sharing a policy. */ unsigned long util; unsigned long max; unsigned int flags; }; static DEFINE_PER_CPU(struct sugov_cpu, sugov_cpu); /************************ Governor internals ***********************/ static bool sugov_should_update_freq(struct sugov_policy *sg_policy, u64 time) { s64 delta_ns; if (sg_policy->work_in_progress) return false; if (unlikely(sg_policy->need_freq_update)) { sg_policy->need_freq_update = false; /* * This happens when limits change, so forget the previous * next_freq value and force an update. */ sg_policy->next_freq = UINT_MAX; return true; } delta_ns = time - sg_policy->last_freq_update_time; return delta_ns >= sg_policy->freq_update_delay_ns; } static void sugov_update_commit(struct sugov_policy *sg_policy, u64 time, unsigned int next_freq) { struct cpufreq_policy *policy = sg_policy->policy; sg_policy->last_freq_update_time = time; if (policy->fast_switch_enabled) { if (sg_policy->next_freq == next_freq) { trace_cpu_frequency(policy->cur, smp_processor_id()); return; } sg_policy->next_freq = next_freq; next_freq = cpufreq_driver_fast_switch(policy, next_freq); if (next_freq == CPUFREQ_ENTRY_INVALID) return; policy->cur = next_freq; trace_cpu_frequency(next_freq, smp_processor_id()); } else if (sg_policy->next_freq != next_freq) { sg_policy->next_freq = next_freq; sg_policy->work_in_progress = true; irq_work_queue(&sg_policy->irq_work); } } /** * get_next_freq - Compute a new frequency for a given cpufreq policy. * @sg_cpu: schedutil cpu 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_cpu *sg_cpu, unsigned long util, unsigned long max) { struct sugov_policy *sg_policy = sg_cpu->sg_policy; struct cpufreq_policy *policy = sg_policy->policy; unsigned int freq = arch_scale_freq_invariant() ? policy->cpuinfo.max_freq : policy->cur; freq = (freq + (freq >> 2)) * util / max; if (freq == sg_cpu->cached_raw_freq && sg_policy->next_freq != UINT_MAX) return sg_policy->next_freq; sg_cpu->cached_raw_freq = freq; return cpufreq_driver_resolve_freq(policy, freq); } static void sugov_get_util(unsigned long *util, unsigned long *max) { struct rq *rq = this_rq(); unsigned long cfs_max; cfs_max = arch_scale_cpu_capacity(NULL, smp_processor_id()); *util = min(rq->cfs.avg.util_avg, cfs_max); *max = cfs_max; } static void sugov_set_iowait_boost(struct sugov_cpu *sg_cpu, u64 time, unsigned int flags) { if (flags & SCHED_CPUFREQ_IOWAIT) { sg_cpu->iowait_boost = sg_cpu->iowait_boost_max; } else if (sg_cpu->iowait_boost) { s64 delta_ns = time - sg_cpu->last_update; /* Clear iowait_boost if the CPU apprears to have been idle. */ if (delta_ns > TICK_NSEC) sg_cpu->iowait_boost = 0; } } static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, unsigned long *util, unsigned long *max) { unsigned long boost_util = sg_cpu->iowait_boost; unsigned long boost_max = sg_cpu->iowait_boost_max; if (!boost_util) return; if (*util * boost_max < *max * boost_util) { *util = boost_util; *max = boost_max; } sg_cpu->iowait_boost >>= 1; } static void sugov_update_single(struct update_util_data *hook, u64 time, unsigned int flags) { struct sugov_cpu *sg_cpu = container_of(hook, struct sugov_cpu, update_util); struct sugov_policy *sg_policy = sg_cpu->sg_policy; struct cpufreq_policy *policy = sg_policy->policy; unsigned long util, max; unsigned int next_f; sugov_set_iowait_boost(sg_cpu, time, flags); sg_cpu->last_update = time; if (!sugov_should_update_freq(sg_policy, time)) return; if (flags & SCHED_CPUFREQ_RT_DL) { next_f = policy->cpuinfo.max_freq; } else { sugov_get_util(&util, &max); sugov_iowait_boost(sg_cpu, &util, &max); next_f = get_next_freq(sg_cpu, util, max); } sugov_update_commit(sg_policy, time, next_f); } static unsigned int sugov_next_freq_shared(struct sugov_cpu *sg_cpu, unsigned long util, unsigned long max, unsigned int flags) { struct sugov_policy *sg_policy = sg_cpu->sg_policy; struct cpufreq_policy *policy = sg_policy->policy; unsigned int max_f = policy->cpuinfo.max_freq; u64 last_freq_update_time = sg_policy->last_freq_update_time; unsigned int j; if (flags & SCHED_CPUFREQ_RT_DL) return max_f; sugov_iowait_boost(sg_cpu, &util, &max); for_each_cpu(j, policy->cpus) { struct sugov_cpu *j_sg_cpu; unsigned long j_util, j_max; s64 delta_ns; if (j == smp_processor_id()) continue; j_sg_cpu = &per_cpu(sugov_cpu, j); /* * If the CPU utilization was last updated before the previous * frequency update and the time elapsed between the last update * of the CPU utilization and the last frequency update is long * enough, don't take the CPU into account as it probably is * idle now (and clear iowait_boost for it). */ delta_ns = last_freq_update_time - j_sg_cpu->last_update; if (delta_ns > TICK_NSEC) { j_sg_cpu->iowait_boost = 0; continue; } if (j_sg_cpu->flags & SCHED_CPUFREQ_RT_DL) return max_f; j_util = j_sg_cpu->util; j_max = j_sg_cpu->max; if (j_util * max > j_max * util) { util = j_util; max = j_max; } sugov_iowait_boost(j_sg_cpu, &util, &max); } return get_next_freq(sg_cpu, util, max); } static void sugov_update_shared(struct update_util_data *hook, u64 time, unsigned int flags) { struct sugov_cpu *sg_cpu = container_of(hook, struct sugov_cpu, update_util); struct sugov_policy *sg_policy = sg_cpu->sg_policy; unsigned long util, max; unsigned int next_f; sugov_get_util(&util, &max); raw_spin_lock(&sg_policy->update_lock); sg_cpu->util = util; sg_cpu->max = max; sg_cpu->flags = flags; sugov_set_iowait_boost(sg_cpu, time, flags); sg_cpu->last_update = time; if (sugov_should_update_freq(sg_policy, time)) { next_f = sugov_next_freq_shared(sg_cpu, util, max, flags); sugov_update_commit(sg_policy, time, next_f); } raw_spin_unlock(&sg_policy->update_lock); } static void sugov_work(struct work_struct *work) { struct sugov_policy *sg_policy = container_of(work, struct sugov_policy, work); mutex_lock(&sg_policy->work_lock); __cpufreq_driver_target(sg_policy->policy, sg_policy->next_freq, CPUFREQ_RELATION_L); mutex_unlock(&sg_policy->work_lock); sg_policy->work_in_progress = false; } static void sugov_irq_work(struct irq_work *irq_work) { struct sugov_policy *sg_policy; sg_policy = container_of(irq_work, struct sugov_policy, irq_work); schedule_work_on(smp_processor_id(), &sg_policy->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) { return container_of(attr_set, struct sugov_tunables, attr_set); } static ssize_t rate_limit_us_show(struct gov_attr_set *attr_set, char *buf) { struct sugov_tunables *tunables = to_sugov_tunables(attr_set); return sprintf(buf, "%u\n", tunables->rate_limit_us); } static ssize_t rate_limit_us_store(struct gov_attr_set *attr_set, const char *buf, size_t count) { struct sugov_tunables *tunables = to_sugov_tunables(attr_set); struct sugov_policy *sg_policy; unsigned int rate_limit_us; if (kstrtouint(buf, 10, &rate_limit_us)) return -EINVAL; tunables->rate_limit_us = rate_limit_us; list_for_each_entry(sg_policy, &attr_set->policy_list, tunables_hook) sg_policy->freq_update_delay_ns = rate_limit_us * NSEC_PER_USEC; return count; } static struct governor_attr rate_limit_us = __ATTR_RW(rate_limit_us); static struct attribute *sugov_attributes[] = { &rate_limit_us.attr, NULL }; static struct kobj_type sugov_tunables_ktype = { .default_attrs = sugov_attributes, .sysfs_ops = &governor_sysfs_ops, }; /********************** cpufreq governor interface *********************/ static struct cpufreq_governor schedutil_gov; static struct sugov_policy *sugov_policy_alloc(struct cpufreq_policy *policy) { struct sugov_policy *sg_policy; sg_policy = kzalloc(sizeof(*sg_policy), GFP_KERNEL); if (!sg_policy) return NULL; sg_policy->policy = policy; init_irq_work(&sg_policy->irq_work, sugov_irq_work); INIT_WORK(&sg_policy->work, sugov_work); mutex_init(&sg_policy->work_lock); raw_spin_lock_init(&sg_policy->update_lock); return sg_policy; } static void sugov_policy_free(struct sugov_policy *sg_policy) { mutex_destroy(&sg_policy->work_lock); kfree(sg_policy); } static struct sugov_tunables *sugov_tunables_alloc(struct sugov_policy *sg_policy) { struct sugov_tunables *tunables; tunables = kzalloc(sizeof(*tunables), GFP_KERNEL); if (tunables) { gov_attr_set_init(&tunables->attr_set, &sg_policy->tunables_hook); if (!have_governor_per_policy()) global_tunables = tunables; } return tunables; } static void sugov_tunables_free(struct sugov_tunables *tunables) { if (!have_governor_per_policy()) global_tunables = NULL; kfree(tunables); } static int sugov_init(struct cpufreq_policy *policy) { struct sugov_policy *sg_policy; struct sugov_tunables *tunables; unsigned int lat; int ret = 0; /* State should be equivalent to EXIT */ if (policy->governor_data) return -EBUSY; sg_policy = sugov_policy_alloc(policy); if (!sg_policy)


context:
space:
mode: