malhuda/msm-4.14
1
0
Fork 0
mirror of https://github.com/rd-stuffs/msm-4.14.git synced 2025-02-20 11:45:48 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

schedutil: Remove up/down rate limits

Browse Source 
To make way for new changes

Change-Id: Ie28ebf8ea187c8c3da79ee896224f6eeb4f513a6
Signed-off-by: Richard Raya <rdxzv.dev@gmail.com>
This commit is contained in:
EmanuelCN 2024-12-14 23:51:24 +02:00 committed by Richard Raya
parent 2f1794050a
commit 86c781853b
1 changed files with 12 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

108
kernel/sched/cpufreq_schedutil.c
View File

@ -22,8 +22,7 @@
struct sugov_tunables {
struct gov_attr_set attr_set;
unsigned int up_rate_limit_us;
unsigned int down_rate_limit_us;
unsigned int rate_limit_us;
bool pl;
};
@ -35,9 +34,6 @@ struct sugov_policy {
raw_spinlock_t update_lock; /* For shared policies */
u64 last_freq_update_time;
s64 min_rate_limit_ns;
s64 up_rate_delay_ns;
s64 down_rate_delay_ns;
s64 freq_update_delay_ns;
u64 last_ws;
u64 curr_cycles;
@ -115,32 +111,8 @@ static bool sugov_should_update_freq(struct sugov_policy *sg_policy, u64 time)
if (sg_policy->work_in_progress)
return true;
/* No need to recalculate next freq for min_rate_limit_us
* at least. However we might still decide to further rate
* limit once frequency change direction is decided, according
* to the separate rate limits.
*/
delta_ns = time - sg_policy->last_freq_update_time;
return delta_ns >= sg_policy->min_rate_limit_ns;
}
static bool sugov_up_down_rate_limit(struct sugov_policy *sg_policy, u64 time,
unsigned int next_freq)
{
s64 delta_ns;
delta_ns = time - sg_policy->last_freq_update_time;
if (next_freq > sg_policy->next_freq &&
delta_ns < sg_policy->up_rate_delay_ns)
return true;
if (next_freq < sg_policy->next_freq &&
delta_ns < sg_policy->down_rate_delay_ns)
return true;
return false;
return delta_ns >= sg_policy->freq_update_delay_ns;
}
static inline bool use_pelt(void)
@ -216,12 +188,6 @@ static bool sugov_update_next_freq(struct sugov_policy *sg_policy, u64 time,
else if (sg_policy->next_freq == next_freq)
return false;
if (sugov_up_down_rate_limit(sg_policy, time, next_freq)) {
/* Restore cached freq as next_freq is not changed */
sg_policy->cached_raw_freq = sg_policy->prev_cached_raw_freq;
return false;
}
sg_policy->next_freq = next_freq;
sg_policy->last_freq_update_time = time;
@ -617,31 +583,14 @@ static inline struct sugov_tunables *to_sugov_tunables(struct gov_attr_set *attr
return container_of(attr_set, struct sugov_tunables, attr_set);
}
static DEFINE_MUTEX(min_rate_lock);
static void update_min_rate_limit_ns(struct sugov_policy *sg_policy)
{
mutex_lock(&min_rate_lock);
sg_policy->min_rate_limit_ns = min(sg_policy->up_rate_delay_ns,
sg_policy->down_rate_delay_ns);
mutex_unlock(&min_rate_lock);
}
static ssize_t up_rate_limit_us_show(struct gov_attr_set *attr_set, char *buf)
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->up_rate_limit_us);
return sprintf(buf, "%u\n", tunables->rate_limit_us);
}
static ssize_t down_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->down_rate_limit_us);
}
static ssize_t up_rate_limit_us_store(struct gov_attr_set *attr_set,
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);
@ -651,32 +600,10 @@ static ssize_t up_rate_limit_us_store(struct gov_attr_set *attr_set,
if (kstrtouint(buf, 10, &rate_limit_us))
return -EINVAL;
tunables->up_rate_limit_us = rate_limit_us;
tunables->rate_limit_us = rate_limit_us;
list_for_each_entry(sg_policy, &attr_set->policy_list, tunables_hook) {
sg_policy->up_rate_delay_ns = rate_limit_us * NSEC_PER_USEC;
update_min_rate_limit_ns(sg_policy);
}
return count;
}
static ssize_t down_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->down_rate_limit_us = rate_limit_us;
list_for_each_entry(sg_policy, &attr_set->policy_list, tunables_hook) {
sg_policy->down_rate_delay_ns = rate_limit_us * NSEC_PER_USEC;
update_min_rate_limit_ns(sg_policy);
}
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;
}
@ -699,13 +626,11 @@ static ssize_t pl_store(struct gov_attr_set *attr_set, const char *buf,
return count;
}
static struct governor_attr up_rate_limit_us = __ATTR_RW(up_rate_limit_us);
static struct governor_attr down_rate_limit_us = __ATTR_RW(down_rate_limit_us);
static struct governor_attr rate_limit_us = __ATTR_RW(rate_limit_us);
static struct governor_attr pl = __ATTR_RW(pl);
static struct attribute *sugov_attributes[] = {
&up_rate_limit_us.attr,
&down_rate_limit_us.attr,
&rate_limit_us.attr,
&pl.attr,
NULL
};
@ -826,8 +751,6 @@ static void sugov_tunables_save(struct cpufreq_policy *policy,
}
cached->pl = tunables->pl;
cached->up_rate_limit_us = tunables->up_rate_limit_us;
cached->down_rate_limit_us = tunables->down_rate_limit_us;
}
static void sugov_clear_global_tunables(void)
@ -846,9 +769,6 @@ static void sugov_tunables_restore(struct cpufreq_policy *policy)
return;
tunables->pl = cached->pl;
tunables->up_rate_limit_us = cached->up_rate_limit_us;
tunables->down_rate_limit_us = cached->down_rate_limit_us;
update_min_rate_limit_ns(sg_policy);
}
static int sugov_init(struct cpufreq_policy *policy)
@ -893,8 +813,7 @@ static int sugov_init(struct cpufreq_policy *policy)
goto stop_kthread;
}
tunables->up_rate_limit_us = 500;
tunables->down_rate_limit_us = 1000;
tunables->rate_limit_us = cpufreq_policy_transition_delay_us(policy);
policy->governor_data = sg_policy;
sg_policy->tunables = tunables;
@ -960,10 +879,7 @@ static int sugov_start(struct cpufreq_policy *policy)
struct sugov_policy *sg_policy = policy->governor_data;
unsigned int cpu;
sg_policy->up_rate_delay_ns =
sg_policy->tunables->up_rate_limit_us * NSEC_PER_USEC;
sg_policy->down_rate_delay_ns =
sg_policy->tunables->down_rate_limit_us * NSEC_PER_USEC;
sg_policy->freq_update_delay_ns = sg_policy->tunables->rate_limit_us * NSEC_PER_USEC;
sg_policy->last_freq_update_time = 0;
sg_policy->next_freq = 0;
sg_policy->work_in_progress = false;