lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[PATCH] cpufreq_conservative: make for_each_cpu() safe

Browse Source 
All these changes should make cpufreq_conservative safe in regards to the x86
for_each_cpu cpumask.h changes and whatnot.

Whilst making it safe a number of pointless for loops related to the cpu
mask's were removed.  I was never comfortable with all those for loops,
especially as the iteration is over the same data again and again for each
CPU you had in a single poll, an O(n^2) outcome to frequency scaling.

The approach I use is to assume by default no CPU's exist and it sets the
requested_freq to zero as a kind of flag, the reasoning is in the source ;)
If the CPU is queried and requested_freq is zero then it initialises the
variable to current_freq and then continues as if nothing happened which
should be the same net effect as before?

Signed-off-by: Alexander Clouter <alex-kernel@digriz.org.uk>
Signed-off-by: Dominik Brodowski <linux@dominikbrodowski.net>
This commit is contained in:
Alexander Clouter
2006-03-22 09:59:16 +00:00
committed by Dominik Brodowski
parent e8a0257225
commit 08a28e2e98
1 changed files with 41 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
drivers/cpufreq/cpufreq_conservative.c
View File

@@ -294,31 +294,40 @@ static struct attribute_group dbs_attr_group = {
static void dbs_check_cpu(int cpu) static void dbs_check_cpu(int cpu)
{ {
unsigned int idle_ticks, up_idle_ticks, down_idle_ticks; unsigned int idle_ticks, up_idle_ticks, down_idle_ticks;
unsigned int tmp_idle_ticks, total_idle_ticks;
unsigned int freq_step; unsigned int freq_step;
unsigned int freq_down_sampling_rate; unsigned int freq_down_sampling_rate;
static int down_skip[NR_CPUS]; static unsigned short down_skip[NR_CPUS];
static int requested_freq[NR_CPUS]; static unsigned int requested_freq[NR_CPUS];
static unsigned short init_flag = 0; static unsigned int init_flag = NR_CPUS;
struct cpu_dbs_info_s *this_dbs_info; struct cpu_dbs_info_s *this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
struct cpu_dbs_info_s *dbs_info;
struct cpufreq_policy *policy; struct cpufreq_policy *policy;
unsigned int j;
this_dbs_info = &per_cpu(cpu_dbs_info, cpu);
if (!this_dbs_info->enable) if (!this_dbs_info->enable)
return; return;
policy = this_dbs_info->cur_policy; if ( init_flag != 0 ) {
for_each_cpu(init_flag) {
if ( init_flag == 0 ) { down_skip[init_flag] = 0;
for_each_online_cpu(j) { /* I doubt a CPU exists with a freq of 0hz :) */
dbs_info = &per_cpu(cpu_dbs_info, j); requested_freq[init_flag] = 0;
requested_freq[j] = dbs_info->cur_policy->cur;
} }
init_flag = 1; init_flag = 0;
} }
/*
* If its a freshly initialised cpu we setup requested_freq. This
* check could be avoided if we did not care about a first time
* stunted increase in CPU speed when there is a load. I feel we
* should be initialising this to something. The removal of a CPU
* is not a problem, after a short time the CPU should settle down
* to a 'natural' frequency.
*/
if (requested_freq[cpu] == 0)
requested_freq[cpu] = this_dbs_info->cur_policy->cur;
policy = this_dbs_info->cur_policy;
/* /*
* The default safe range is 20% to 80% * The default safe range is 20% to 80%
* Every sampling_rate, we check * Every sampling_rate, we check
@@ -335,20 +344,15 @@ static void dbs_check_cpu(int cpu)
/* Check for frequency increase */ /* Check for frequency increase */
idle_ticks = UINT_MAX; idle_ticks = UINT_MAX;
for_each_cpu_mask(j, policy->cpus) {
unsigned int tmp_idle_ticks, total_idle_ticks;
struct cpu_dbs_info_s *j_dbs_info;
j_dbs_info = &per_cpu(cpu_dbs_info, j); /* Check for frequency increase */
/* Check for frequency increase */ total_idle_ticks = get_cpu_idle_time(cpu);
total_idle_ticks = get_cpu_idle_time(j); tmp_idle_ticks = total_idle_ticks -
tmp_idle_ticks = total_idle_ticks - this_dbs_info->prev_cpu_idle_up;
j_dbs_info->prev_cpu_idle_up; this_dbs_info->prev_cpu_idle_up = total_idle_ticks;
j_dbs_info->prev_cpu_idle_up = total_idle_ticks;
if (tmp_idle_ticks < idle_ticks) if (tmp_idle_ticks < idle_ticks)
idle_ticks = tmp_idle_ticks; idle_ticks = tmp_idle_ticks;
}
/* Scale idle ticks by 100 and compare with up and down ticks */ /* Scale idle ticks by 100 and compare with up and down ticks */
idle_ticks *= 100; idle_ticks *= 100;
@@ -357,13 +361,9 @@ static void dbs_check_cpu(int cpu)
if (idle_ticks < up_idle_ticks) { if (idle_ticks < up_idle_ticks) {
down_skip[cpu] = 0; down_skip[cpu] = 0;
for_each_cpu_mask(j, policy->cpus) { this_dbs_info->prev_cpu_idle_down =
struct cpu_dbs_info_s *j_dbs_info; this_dbs_info->prev_cpu_idle_up;
j_dbs_info = &per_cpu(cpu_dbs_info, j);
j_dbs_info->prev_cpu_idle_down =
j_dbs_info->prev_cpu_idle_up;
}
/* if we are already at full speed then break out early */ /* if we are already at full speed then break out early */
if (requested_freq[cpu] == policy->max) if (requested_freq[cpu] == policy->max)
return; return;
@@ -388,21 +388,14 @@ static void dbs_check_cpu(int cpu)
if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor) if (down_skip[cpu] < dbs_tuners_ins.sampling_down_factor)
return; return;
idle_ticks = UINT_MAX; /* Check for frequency decrease */
for_each_cpu_mask(j, policy->cpus) { total_idle_ticks = this_dbs_info->prev_cpu_idle_up;
unsigned int tmp_idle_ticks, total_idle_ticks; tmp_idle_ticks = total_idle_ticks -
struct cpu_dbs_info_s *j_dbs_info; this_dbs_info->prev_cpu_idle_down;
this_dbs_info->prev_cpu_idle_down = total_idle_ticks;
j_dbs_info = &per_cpu(cpu_dbs_info, j); if (tmp_idle_ticks < idle_ticks)
/* Check for frequency decrease */ idle_ticks = tmp_idle_ticks;
total_idle_ticks = j_dbs_info->prev_cpu_idle_up;
tmp_idle_ticks = total_idle_ticks -
j_dbs_info->prev_cpu_idle_down;
j_dbs_info->prev_cpu_idle_down = total_idle_ticks;
if (tmp_idle_ticks < idle_ticks)
idle_ticks = tmp_idle_ticks;
}
/* Scale idle ticks by 100 and compare with up and down ticks */ /* Scale idle ticks by 100 and compare with up and down ticks */
idle_ticks *= 100; idle_ticks *= 100;
@@ -491,7 +484,7 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy,
j_dbs_info = &per_cpu(cpu_dbs_info, j); j_dbs_info = &per_cpu(cpu_dbs_info, j);
j_dbs_info->cur_policy = policy; j_dbs_info->cur_policy = policy;
j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(j); j_dbs_info->prev_cpu_idle_up = get_cpu_idle_time(cpu);
j_dbs_info->prev_cpu_idle_down j_dbs_info->prev_cpu_idle_down
= j_dbs_info->prev_cpu_idle_up; = j_dbs_info->prev_cpu_idle_up;
} }