xen/18879-cpufreq-params.patch

# HG changeset patch
# User Keir Fraser <keir.fraser@citrix.com>
# Date 1228490612 0
# Node ID de7fd862ada2ed079d0a5c407508eb63bb936992
# Parent  3905cbf523b2550f5025df6cc31ac60e48c1706f
cpufreq: allow customization of some parameters

Short of having a way for powersaved to dynamically adjust these
values, at least allow specifying them on the command line. In
particular, always running at an up-threshold of 80% is perhaps nice
for laptop use, but certainly not desirable on servers. On shell
scripts invoking large numbers of short-lived processes I noticed a
50% performance degradation on a dual-socket quad-core Barcelona just
because of the load of an individual core never crossing the 80%
boundary that would have resulted in increasing the frequency.

(Powersaved on SLE10 sets this on native kernels to 60% or 80%,
depending on whether performance or power reduction is preferred,
*divided* by the number of CPUs, but capped at the lower limit of
20%.)

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

# HG changeset patch
# User Keir Fraser <keir.fraser@citrix.com>
# Date 1230557866 0
# Node ID 4035ea96ae2fafba7a5a4c1e810aa7d591758e8c
# Parent  0af9fbf3f05306d4972cf05e4b6d7be2199a41cb
cpufreq: Fix a cpufreq cmdline parse bug, and change sample_rate unit

Signed-off-by: Liu Jinsong <jinsong.liu@intel.com>

--- a/xen/arch/x86/acpi/cpufreq/cpufreq_ondemand.c
+++ b/xen/arch/x86/acpi/cpufreq/cpufreq_ondemand.c
@@ -22,15 +22,22 @@
 #include <acpi/cpufreq/cpufreq.h>
 
 #define DEF_FREQUENCY_UP_THRESHOLD              (80)
+#define MIN_FREQUENCY_UP_THRESHOLD              (11)
+#define MAX_FREQUENCY_UP_THRESHOLD              (100)
 
 #define MIN_DBS_INTERVAL                        (MICROSECS(100))
-#define MIN_SAMPLING_MILLISECS                  (20)
-#define MIN_STAT_SAMPLING_RATE                   \
+#define MIN_SAMPLING_RATE_RATIO                 (2)
+#define MIN_SAMPLING_MILLISECS                  (MIN_SAMPLING_RATE_RATIO * 10)
+#define MIN_STAT_SAMPLING_RATE                  \
     (MIN_SAMPLING_MILLISECS * MILLISECS(1))
+#define MIN_SAMPLING_RATE                       \
+    (def_sampling_rate / MIN_SAMPLING_RATE_RATIO)
+#define MAX_SAMPLING_RATE                       (500 * def_sampling_rate)
 #define DEF_SAMPLING_RATE_LATENCY_MULTIPLIER    (1000)
 #define TRANSITION_LATENCY_LIMIT                (10 * 1000 )
 
 static uint64_t def_sampling_rate;
+static uint64_t usr_sampling_rate;
 
 /* Sampling types */
 enum {DBS_NORMAL_SAMPLE, DBS_SUB_SAMPLE};
@@ -42,11 +49,9 @@ static unsigned int dbs_enable;    /* nu
 static struct dbs_tuners {
     uint64_t     sampling_rate;
     unsigned int up_threshold;
-    unsigned int ignore_nice;
     unsigned int powersave_bias;
 } dbs_tuners_ins = {
     .up_threshold = DEF_FREQUENCY_UP_THRESHOLD,
-    .ignore_nice = 0,
     .powersave_bias = 0,
 };
 
@@ -216,7 +221,20 @@ int cpufreq_governor_dbs(struct cpufreq_
             if (def_sampling_rate < MIN_STAT_SAMPLING_RATE)
                 def_sampling_rate = MIN_STAT_SAMPLING_RATE;
 
-            dbs_tuners_ins.sampling_rate = def_sampling_rate;
+            if (!usr_sampling_rate)
+                dbs_tuners_ins.sampling_rate = def_sampling_rate;
+            else if (usr_sampling_rate < MIN_SAMPLING_RATE) {
+                printk(KERN_WARNING "cpufreq/ondemand: "
+                       "specified sampling rate too low, using %"PRIu64"\n",
+                       MIN_SAMPLING_RATE);
+                dbs_tuners_ins.sampling_rate = MIN_SAMPLING_RATE;
+            } else if (usr_sampling_rate > MAX_SAMPLING_RATE) {
+                printk(KERN_WARNING "cpufreq/ondemand: "
+                       "specified sampling rate too high, using %"PRIu64"\n",
+                       MAX_SAMPLING_RATE);
+                dbs_tuners_ins.sampling_rate = MAX_SAMPLING_RATE;
+            } else
+                dbs_tuners_ins.sampling_rate = usr_sampling_rate;
         }
         dbs_timer_init(this_dbs_info);
 
@@ -239,3 +257,55 @@ int cpufreq_governor_dbs(struct cpufreq_
     }
     return 0;
 } 
+
+void __init cpufreq_cmdline_parse(char *str)
+{
+    do {
+        char *val, *end = strchr(str, ',');
+
+        if ( end )
+            *end++ = '\0';
+        val = strchr(str, '=');
+        if ( val )
+            *val++ = '\0';
+
+        if ( !strcmp(str, "rate") && val )
+        {
+            usr_sampling_rate = simple_strtoull(val, NULL, 0) * MICROSECS(1);
+        }
+        else if ( !strcmp(str, "threshold") && val )
+        {
+            unsigned long tmp = simple_strtoul(val, NULL, 0);
+
+            if ( tmp < MIN_FREQUENCY_UP_THRESHOLD )
+            {
+                printk(XENLOG_WARNING "cpufreq/ondemand: "
+                       "specified threshold too low, using %d\n",
+                       MIN_FREQUENCY_UP_THRESHOLD);
+                tmp = MIN_FREQUENCY_UP_THRESHOLD;
+            }
+            else if ( tmp > MAX_FREQUENCY_UP_THRESHOLD )
+            {
+                printk(XENLOG_WARNING "cpufreq/ondemand: "
+                       "specified threshold too high, using %d\n",
+                       MAX_FREQUENCY_UP_THRESHOLD);
+                tmp = MAX_FREQUENCY_UP_THRESHOLD;
+            }
+            dbs_tuners_ins.up_threshold = tmp;
+        }
+        else if ( !strcmp(str, "bias") && val )
+        {
+            unsigned long tmp = simple_strtoul(val, NULL, 0);
+
+            if ( tmp > 1000 )
+            {
+                printk(XENLOG_WARNING "cpufreq/ondemand: "
+                       "specified bias too high, using 1000\n");
+                tmp = 1000;
+            }
+            dbs_tuners_ins.powersave_bias = tmp;
+        }
+
+        str = end;
+    } while ( str );
+}
--- a/xen/common/domain.c
+++ b/xen/common/domain.c
@@ -25,6 +25,7 @@
 #include <xen/percpu.h>
 #include <xen/multicall.h>
 #include <xen/rcupdate.h>
+#include <acpi/cpufreq/cpufreq.h>
 #include <asm/debugger.h>
 #include <public/sched.h>
 #include <public/vcpu.h>
@@ -41,16 +42,25 @@ boolean_param("dom0_vcpus_pin", opt_dom0
 enum cpufreq_controller cpufreq_controller;
 static void __init setup_cpufreq_option(char *str)
 {
+    char *arg;
+
     if ( !strcmp(str, "dom0-kernel") )
     {
         xen_processor_pmbits &= ~XEN_PROCESSOR_PM_PX;
         cpufreq_controller = FREQCTL_dom0_kernel;
         opt_dom0_vcpus_pin = 1;
+        return;
     }
-    else if ( !strcmp(str, "xen") )
+
+    if ( (arg = strpbrk(str, ",:")) != NULL )
+        *arg++ = '\0';
+
+    if ( !strcmp(str, "xen") )
     {
         xen_processor_pmbits |= XEN_PROCESSOR_PM_PX;
         cpufreq_controller = FREQCTL_xen;
+        if ( arg && *arg )
+            cpufreq_cmdline_parse(arg);
     }
 }
 custom_param("cpufreq", setup_cpufreq_option);
--- a/xen/include/acpi/cpufreq/cpufreq.h
+++ b/xen/include/acpi/cpufreq/cpufreq.h
@@ -41,6 +41,8 @@ struct cpufreq_policy {
 };
 extern struct cpufreq_policy xen_px_policy[NR_CPUS];
 
+void cpufreq_cmdline_parse(char *);
+
 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
 #define CPUFREQ_SHARED_TYPE_HW   (1) /* HW does needed coordination */
 #define CPUFREQ_SHARED_TYPE_ALL  (2) /* All dependent CPUs should set freq */