cpufreq: governor: Drop min_sampling_rate

The cpufreq core and governors aren't supposed to set a limit on how
fast we want to try changing the frequency. This is currently done for
the legacy governors with help of min_sampling_rate.

At worst, we may end up setting the sampling rate to a value lower than
the rate at which frequency can be changed and then one of the CPUs in
the policy will be only changing frequency for ever.

But that is something for the user to decide and there is no need to
have special handling for such cases in the core. Leave it for the user
to figure out.

Signed-off-by: Viresh Kumar <[email protected]>
Signed-off-by: Rafael J. Wysocki <[email protected]>

diff --git a/Documentation/admin-guide/pm/cpufreq.rst b/Documentation/admin-guide/pm/cpufreq.rst
index 463cf7e73db80b3bf3f8a36afe91bcf3d7f0d429..2eb3bf62393ee1ec785c208145d6b233d2bf5db1 100644 (file)
--- a/Documentation/admin-guide/pm/cpufreq.rst
+++ b/Documentation/admin-guide/pm/cpufreq.rst
@@ -471,14 +471,6 @@ This governor exposes the following tunables:
 
        # echo `$(($(cat cpuinfo_transition_latency) * 750 / 1000)) > ondemand/sampling_rate
 
-
-``min_sampling_rate``
-       The minimum value of ``sampling_rate``.
-
-       Equal to 10000 (10 ms) if :c:macro:`CONFIG_NO_HZ_COMMON` and
-       :c:data:`tick_nohz_active` are both set or to 20 times the value of
-       :c:data:`jiffies` in microseconds otherwise.
-
 ``up_threshold``
        If the estimated CPU load is above this value (in percent), the governor
        will set the frequency to the maximum value allowed for the policy.

diff --git a/drivers/cpufreq/cpufreq_conservative.c b/drivers/cpufreq/cpufreq_conservative.c
index 88220ff3e1c226277e7ef8895317a5a1314ddee6..f20f20a77d4d37cad47eea9673552478dd1ccf32 100644 (file)
--- a/drivers/cpufreq/cpufreq_conservative.c
+++ b/drivers/cpufreq/cpufreq_conservative.c
@@ -246,7 +246,6 @@ gov_show_one_common(sampling_rate);
 gov_show_one_common(sampling_down_factor);
 gov_show_one_common(up_threshold);
 gov_show_one_common(ignore_nice_load);
-gov_show_one_common(min_sampling_rate);
 gov_show_one(cs, down_threshold);
 gov_show_one(cs, freq_step);
 
@@ -254,12 +253,10 @@ gov_attr_rw(sampling_rate);
 gov_attr_rw(sampling_down_factor);
 gov_attr_rw(up_threshold);
 gov_attr_rw(ignore_nice_load);
-gov_attr_ro(min_sampling_rate);
 gov_attr_rw(down_threshold);
 gov_attr_rw(freq_step);
 
 static struct attribute *cs_attributes[] = {
-       &min_sampling_rate.attr,
        &sampling_rate.attr,
        &sampling_down_factor.attr,
        &up_threshold.attr,
@@ -297,10 +294,7 @@ static int cs_init(struct dbs_data *dbs_data)
        dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
        dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;
        dbs_data->ignore_nice_load = 0;
-
        dbs_data->tuners = tuners;
-       dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
-               jiffies_to_usecs(10);
 
        return 0;
 }

diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index 47e24b5384b37978cde5ce1f0e2eeb440e6ea04b..858081f9c3d73aa7d81e4b609191f9c419b7829c 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -47,14 +47,11 @@ ssize_t store_sampling_rate(struct gov_attr_set *attr_set, const char *buf,
 {
        struct dbs_data *dbs_data = to_dbs_data(attr_set);
        struct policy_dbs_info *policy_dbs;
-       unsigned int rate;
        int ret;
-       ret = sscanf(buf, "%u", &rate);
+       ret = sscanf(buf, "%u", &dbs_data->sampling_rate);
        if (ret != 1)
                return -EINVAL;
 
-       dbs_data->sampling_rate = max(rate, dbs_data->min_sampling_rate);
-
        /*
         * We are operating under dbs_data->mutex and so the list and its
         * entries can't be freed concurrently.
@@ -437,10 +434,7 @@ int cpufreq_dbs_governor_init(struct cpufreq_policy *policy)
                latency = 1;
 
        /* Bring kernel and HW constraints together */
-       dbs_data->min_sampling_rate = max(dbs_data->min_sampling_rate,
-                                         MIN_LATENCY_MULTIPLIER * latency);
-       dbs_data->sampling_rate = max(dbs_data->min_sampling_rate,
-                                     LATENCY_MULTIPLIER * latency);
+       dbs_data->sampling_rate = LATENCY_MULTIPLIER * latency;
 
        if (!have_governor_per_policy())
                gov->gdbs_data = dbs_data;

diff --git a/drivers/cpufreq/cpufreq_governor.h b/drivers/cpufreq/cpufreq_governor.h
index 0236ec2cd654b34bb9fb1e42d416138f63619b10..95f207eb820e363a759aa504948e93aeb2812684 100644 (file)
--- a/drivers/cpufreq/cpufreq_governor.h
+++ b/drivers/cpufreq/cpufreq_governor.h
@@ -41,7 +41,6 @@ enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
 struct dbs_data {
        struct gov_attr_set attr_set;
        void *tuners;
-       unsigned int min_sampling_rate;
        unsigned int ignore_nice_load;
        unsigned int sampling_rate;
        unsigned int sampling_down_factor;

diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c
index 3937acf7e026cdf80296f1eef4116e1774b76dab..6b423eebfd5dbefccc2f20e52825271d0b2a7114 100644 (file)
--- a/drivers/cpufreq/cpufreq_ondemand.c
+++ b/drivers/cpufreq/cpufreq_ondemand.c
@@ -319,7 +319,6 @@ gov_show_one_common(sampling_rate);
 gov_show_one_common(up_threshold);
 gov_show_one_common(sampling_down_factor);
 gov_show_one_common(ignore_nice_load);
-gov_show_one_common(min_sampling_rate);
 gov_show_one_common(io_is_busy);
 gov_show_one(od, powersave_bias);
 
@@ -329,10 +328,8 @@ gov_attr_rw(up_threshold);
 gov_attr_rw(sampling_down_factor);
 gov_attr_rw(ignore_nice_load);
 gov_attr_rw(powersave_bias);
-gov_attr_ro(min_sampling_rate);
 
 static struct attribute *od_attributes[] = {
-       &min_sampling_rate.attr,
        &sampling_rate.attr,
        &up_threshold.attr,
        &sampling_down_factor.attr,
@@ -373,17 +370,8 @@ static int od_init(struct dbs_data *dbs_data)
        if (idle_time != -1ULL) {
                /* Idle micro accounting is supported. Use finer thresholds */
                dbs_data->up_threshold = MICRO_FREQUENCY_UP_THRESHOLD;
-               /*
-                * In nohz/micro accounting case we set the minimum frequency
-                * not depending on HZ, but fixed (very low).
-               */
-               dbs_data->min_sampling_rate = MICRO_FREQUENCY_MIN_SAMPLE_RATE;
        } else {
                dbs_data->up_threshold = DEF_FREQUENCY_UP_THRESHOLD;
-
-               /* For correct statistics, we need 10 ticks for each measure */
-               dbs_data->min_sampling_rate = MIN_SAMPLING_RATE_RATIO *
-                       jiffies_to_usecs(10);
        }
 
        dbs_data->sampling_down_factor = DEF_SAMPLING_DOWN_FACTOR;

diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index f10a9b3761cdbef777c38a131cc1cb1e4aec0c1e..02aec384cab97dad6fe2fbaae50ab3beff0c47a3 100644 (file)
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -491,9 +491,7 @@ static inline unsigned long cpufreq_scale(unsigned long old, u_int div,
  * For CPUs with transition latency > 10ms (mostly drivers with CPUFREQ_ETERNAL)
  * the ondemand governor will not work. All times here are in us (microseconds).
  */
-#define MIN_SAMPLING_RATE_RATIO                (2)
 #define LATENCY_MULTIPLIER             (1000)
-#define MIN_LATENCY_MULTIPLIER         (20)
 #define TRANSITION_LATENCY_LIMIT       (10 * 1000 * 1000)
 
 struct cpufreq_governor {