cpufreq: eliminate unnecessary NR_CPUS-sized arrays

Replace them with per-CPU data.

Signed-off-by: Jan Beulich <jbeulich@novell.com>

4 files changed, 34 insertions, 35 deletions

diff --git a/xen/drivers/cpufreq/cpufreq.c b/xen/drivers/cpufreq/cpufreq.c
index d81a952815..9b2954fc09 100644
--- a/xen/drivers/cpufreq/cpufreq.c
+++ b/xen/drivers/cpufreq/cpufreq.c
@@ -90,8 +90,7 @@ int cpufreq_register_governor(struct cpufreq_governor *governor)
 
 int cpufreq_unregister_governor(struct cpufreq_governor *governor)
 {
-    int cpu = smp_processor_id();
-    struct cpufreq_policy *policy = cpufreq_cpu_policy[cpu];
+    struct cpufreq_policy *policy = this_cpu(cpufreq_cpu_policy);
 
     if (!governor || !policy)
         return -EINVAL;
@@ -110,10 +109,11 @@ int cpufreq_unregister_governor(struct cpufreq_governor *governor)
 int cpufreq_limit_change(unsigned int cpu)
 {
     struct processor_performance *perf = &processor_pminfo[cpu]->perf;
-    struct cpufreq_policy *data = cpufreq_cpu_policy[cpu];
+    struct cpufreq_policy *data;
     struct cpufreq_policy policy;
 
-    if (!cpu_online(cpu) || !data || !processor_pminfo[cpu])
+    if (!cpu_online(cpu) || !(data = per_cpu(cpufreq_cpu_policy, cpu)) ||
+        !processor_pminfo[cpu])
         return -ENODEV;
 
     if ((perf->platform_limit < 0) || 
@@ -149,7 +149,7 @@ int cpufreq_add_cpu(unsigned int cpu)
     if (!cpufreq_driver)
         return 0;
 
-    if (cpufreq_cpu_policy[cpu])
+    if (per_cpu(cpufreq_cpu_policy, cpu))
         return 0;
 
     if (perf->shared_type == CPUFREQ_SHARED_TYPE_HW)
@@ -200,21 +200,21 @@ int cpufreq_add_cpu(unsigned int cpu)
 
         memset(policy, 0, sizeof(struct cpufreq_policy));
         policy->cpu = cpu;
-        cpufreq_cpu_policy[cpu] = policy;
+        per_cpu(cpufreq_cpu_policy, cpu) = policy;
 
         ret = cpufreq_driver->init(policy);
         if (ret) {
             xfree(policy);
-            cpufreq_cpu_policy[cpu] = NULL;
+            per_cpu(cpufreq_cpu_policy, cpu) = NULL;
             return ret;
         }
         if (cpufreq_verbose)
             printk("CPU %u initialization completed\n", cpu);
     } else {
         firstcpu = first_cpu(cpufreq_dom->map);
-        policy = cpufreq_cpu_policy[firstcpu];
+        policy = per_cpu(cpufreq_cpu_policy, firstcpu);
 
-        cpufreq_cpu_policy[cpu] = policy;
+        per_cpu(cpufreq_cpu_policy, cpu) = policy;
         if (cpufreq_verbose)
             printk("adding CPU %u\n", cpu);
     }
@@ -255,7 +255,7 @@ int cpufreq_add_cpu(unsigned int cpu)
 err2:
     cpufreq_statistic_exit(cpu);
 err1:
-    cpufreq_cpu_policy[cpu] = NULL;
+    per_cpu(cpufreq_cpu_policy, cpu) = NULL;
     cpu_clear(cpu, policy->cpus);
     cpu_clear(cpu, cpufreq_dom->map);
 
@@ -287,14 +287,14 @@ int cpufreq_del_cpu(unsigned int cpu)
         !cpu_online(cpu))
         return -EINVAL;
 
-    if (!cpufreq_cpu_policy[cpu])
+    if (!per_cpu(cpufreq_cpu_policy, cpu))
         return 0;
 
     if (perf->shared_type == CPUFREQ_SHARED_TYPE_HW)
         hw_all = 1;
 
     dom = perf->domain_info.domain;
-    policy = cpufreq_cpu_policy[cpu];
+    policy = per_cpu(cpufreq_cpu_policy, cpu);
 
     list_for_each(pos, &cpufreq_dom_list_head) {
         cpufreq_dom = list_entry(pos, struct cpufreq_dom, node);
@@ -314,7 +314,7 @@ int cpufreq_del_cpu(unsigned int cpu)
         __cpufreq_governor(policy, CPUFREQ_GOV_STOP);
 
     cpufreq_statistic_exit(cpu);
-    cpufreq_cpu_policy[cpu] = NULL;
+    per_cpu(cpufreq_cpu_policy, cpu) = NULL;
     cpu_clear(cpu, policy->cpus);
     cpu_clear(cpu, cpufreq_dom->map);
 
diff --git a/xen/drivers/cpufreq/cpufreq_misc_governors.c b/xen/drivers/cpufreq/cpufreq_misc_governors.c
index 1c63ec1815..f33143a4b3 100644
--- a/xen/drivers/cpufreq/cpufreq_misc_governors.c
+++ b/xen/drivers/cpufreq/cpufreq_misc_governors.c
@@ -63,9 +63,9 @@ static int cpufreq_governor_userspace(struct cpufreq_policy *policy,
 
 int write_userspace_scaling_setspeed(unsigned int cpu, unsigned int freq)
 {
-    struct cpufreq_policy *policy = cpufreq_cpu_policy[cpu];
+    struct cpufreq_policy *policy;
 
-    if (!cpu_online(cpu) || !policy)
+    if (!cpu_online(cpu) || !(policy = per_cpu(cpufreq_cpu_policy, cpu)))
         return -EINVAL;
 
     cpu_set_freq[cpu] = freq;
diff --git a/xen/drivers/cpufreq/cpufreq_ondemand.c b/xen/drivers/cpufreq/cpufreq_ondemand.c
index f69dd7a19c..8a717cb2df 100644
--- a/xen/drivers/cpufreq/cpufreq_ondemand.c
+++ b/xen/drivers/cpufreq/cpufreq_ondemand.c
@@ -56,7 +56,7 @@ static struct dbs_tuners {
     .powersave_bias = 0,
 };
 
-static struct timer dbs_timer[NR_CPUS];
+static DEFINE_PER_CPU(struct timer, dbs_timer);
 
 int write_ondemand_sampling_rate(unsigned int sampling_rate)
 {
@@ -181,7 +181,7 @@ static void do_dbs_timer(void *dbs)
 
     dbs_check_cpu(dbs_info);
 
-    set_timer(&dbs_timer[dbs_info->cpu],
+    set_timer(&per_cpu(dbs_timer, dbs_info->cpu),
             align_timer(NOW() , dbs_tuners_ins.sampling_rate));
 }
 
@@ -189,10 +189,10 @@ static void dbs_timer_init(struct cpu_dbs_info_s *dbs_info)
 {
     dbs_info->enable = 1;
 
-    init_timer(&dbs_timer[dbs_info->cpu], do_dbs_timer, 
+    init_timer(&per_cpu(dbs_timer, dbs_info->cpu), do_dbs_timer,
         (void *)dbs_info, dbs_info->cpu);
 
-    set_timer(&dbs_timer[dbs_info->cpu], NOW()+dbs_tuners_ins.sampling_rate);
+    set_timer(&per_cpu(dbs_timer, dbs_info->cpu), NOW()+dbs_tuners_ins.sampling_rate);
 
     if ( processor_pminfo[dbs_info->cpu]->perf.shared_type
             == CPUFREQ_SHARED_TYPE_HW )
@@ -205,7 +205,7 @@ static void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info)
 {
     dbs_info->enable = 0;
     dbs_info->stoppable = 0;
-    kill_timer(&dbs_timer[dbs_info->cpu]);
+    kill_timer(&per_cpu(dbs_timer, dbs_info->cpu));
 }
 
 int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event)
@@ -362,7 +362,7 @@ void cpufreq_dbs_timer_suspend(void)
 
     if ( per_cpu(cpu_dbs_info,cpu).stoppable )
     {
-        stop_timer( &dbs_timer[cpu] );
+        stop_timer( &per_cpu(dbs_timer, cpu) );
     }
 }
 
@@ -377,7 +377,7 @@ void cpufreq_dbs_timer_resume(void)
     if ( per_cpu(cpu_dbs_info,cpu).stoppable )
     {
         now = NOW();
-        t = &dbs_timer[cpu];
+        t = &per_cpu(dbs_timer, cpu);
         if (t->expires <= now)
         {
             t->function(t->data);
diff --git a/xen/drivers/cpufreq/utility.c b/xen/drivers/cpufreq/utility.c
index 3085173ae0..8fb349246e 100644
--- a/xen/drivers/cpufreq/utility.c
+++ b/xen/drivers/cpufreq/utility.c
@@ -34,7 +34,7 @@
 
 struct cpufreq_driver   *cpufreq_driver;
 struct processor_pminfo *__read_mostly processor_pminfo[NR_CPUS];
-struct cpufreq_policy   *__read_mostly cpufreq_cpu_policy[NR_CPUS];
+DEFINE_PER_CPU_READ_MOSTLY(struct cpufreq_policy *, cpufreq_cpu_policy);
 
 DEFINE_PER_CPU(spinlock_t, cpufreq_statistic_lock);
 
@@ -46,7 +46,7 @@ void cpufreq_residency_update(unsigned int cpu, uint8_t state)
 {
     uint64_t now, total_idle_ns;
     int64_t delta;
-    struct pm_px *pxpt = cpufreq_statistic_data[cpu];
+    struct pm_px *pxpt = per_cpu(cpufreq_statistic_data, cpu);
 
     total_idle_ns = get_cpu_idle_time(cpu);
     now = NOW();
@@ -70,7 +70,7 @@ void cpufreq_statistic_update(unsigned int cpu, uint8_t from, uint8_t to)
 
     spin_lock(cpufreq_statistic_lock);
 
-    pxpt = cpufreq_statistic_data[cpu];
+    pxpt = per_cpu(cpufreq_statistic_data, cpu);
     if ( !pxpt || !pmpt ) {
         spin_unlock(cpufreq_statistic_lock);
         return;
@@ -102,7 +102,7 @@ int cpufreq_statistic_init(unsigned int cpuid)
 
     spin_lock(cpufreq_statistic_lock);
 
-    pxpt = cpufreq_statistic_data[cpuid];
+    pxpt = per_cpu(cpufreq_statistic_data, cpuid);
     if ( pxpt ) {
         spin_unlock(cpufreq_statistic_lock);
         return 0;
@@ -116,7 +116,7 @@ int cpufreq_statistic_init(unsigned int cpuid)
         return -ENOMEM;
     }
     memset(pxpt, 0, sizeof(*pxpt));
-    cpufreq_statistic_data[cpuid] = pxpt;
+    per_cpu(cpufreq_statistic_data, cpuid) = pxpt;
 
     pxpt->u.trans_pt = xmalloc_array(uint64_t, count * count);
     if (!pxpt->u.trans_pt) {
@@ -158,7 +158,7 @@ void cpufreq_statistic_exit(unsigned int cpuid)
 
     spin_lock(cpufreq_statistic_lock);
 
-    pxpt = cpufreq_statistic_data[cpuid];
+    pxpt = per_cpu(cpufreq_statistic_data, cpuid);
     if (!pxpt) {
         spin_unlock(cpufreq_statistic_lock);
         return;
@@ -167,7 +167,7 @@ void cpufreq_statistic_exit(unsigned int cpuid)
     xfree(pxpt->u.trans_pt);
     xfree(pxpt->u.pt);
     xfree(pxpt);
-    cpufreq_statistic_data[cpuid] = NULL;
+    per_cpu(cpufreq_statistic_data, cpuid) = NULL;
 
     spin_unlock(cpufreq_statistic_lock);
 }
@@ -182,7 +182,7 @@ void cpufreq_statistic_reset(unsigned int cpuid)
 
     spin_lock(cpufreq_statistic_lock);
 
-    pxpt = cpufreq_statistic_data[cpuid];
+    pxpt = per_cpu(cpufreq_statistic_data, cpuid);
     if ( !pmpt || !pxpt || !pxpt->u.pt || !pxpt->u.trans_pt ) {
         spin_unlock(cpufreq_statistic_lock);
         return;
@@ -382,8 +382,7 @@ int cpufreq_driver_getavg(unsigned int cpu, unsigned int flag)
     struct cpufreq_policy *policy;
     int freq_avg;
 
-    policy = cpufreq_cpu_policy[cpu];
-    if (!cpu_online(cpu) || !policy)
+    if (!cpu_online(cpu) || !(policy = per_cpu(cpufreq_cpu_policy, cpu)))
         return 0;
 
     if (cpufreq_driver->getavg)
@@ -400,7 +399,7 @@ void cpufreq_enable_turbo(int cpuid)
 {
     struct cpufreq_policy *policy;
 
-    policy = cpufreq_cpu_policy[cpuid];
+    policy = per_cpu(cpufreq_cpu_policy, cpuid);
     if (policy->turbo != CPUFREQ_TURBO_UNSUPPORTED)
         policy->turbo = CPUFREQ_TURBO_ENABLED;
 }
@@ -409,7 +408,7 @@ void cpufreq_disable_turbo(int cpuid)
 {
     struct cpufreq_policy *policy;
 
-    policy = cpufreq_cpu_policy[cpuid];
+    policy = per_cpu(cpufreq_cpu_policy, cpuid);
     if (policy->turbo != CPUFREQ_TURBO_UNSUPPORTED)
         policy->turbo = CPUFREQ_TURBO_DISABLED;
 }
@@ -418,7 +417,7 @@ int cpufreq_get_turbo_status(int cpuid)
 {
     struct cpufreq_policy *policy;
 
-    policy = cpufreq_cpu_policy[cpuid];
+    policy = per_cpu(cpufreq_cpu_policy, cpuid);
     return policy->turbo;
 }