2012-10-25 22:47:42 +00:00
|
|
|
/*
|
|
|
|
|
* drivers/cpufreq/cpufreq_governor.h
|
|
|
|
|
*
|
|
|
|
|
* Header file for CPUFreq governors common code
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2001 Russell King
|
|
|
|
|
* (C) 2003 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>.
|
|
|
|
|
* (C) 2003 Jun Nakajima <jun.nakajima@intel.com>
|
|
|
|
|
* (C) 2009 Alexander Clouter <alex@digriz.org.uk>
|
|
|
|
|
* (c) 2012 Viresh Kumar <viresh.kumar@linaro.org>
|
|
|
|
|
*
|
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
|
*/
|
|
|
|
|
|
2013-04-02 12:26:15 +00:00
|
|
|
#ifndef _CPUFREQ_GOVERNOR_H
|
|
|
|
|
#define _CPUFREQ_GOVERNOR_H
|
2012-10-25 22:47:42 +00:00
|
|
|
|
2015-12-08 20:44:05 +00:00
|
|
|
#include <linux/atomic.h>
|
2016-02-10 15:53:50 +00:00
|
|
|
#include <linux/irq_work.h>
|
2012-10-25 22:47:42 +00:00
|
|
|
#include <linux/cpufreq.h>
|
2013-08-06 17:23:03 +00:00
|
|
|
#include <linux/kernel_stat.h>
|
|
|
|
|
#include <linux/module.h>
|
2012-10-25 22:47:42 +00:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The polling frequency depends on the capability of the processor. Default
|
|
|
|
|
* polling frequency is 1000 times the transition latency of the processor. The
|
2013-08-26 18:42:21 +00:00
|
|
|
* governor will work on any processor with transition latency <= 10ms, using
|
2012-10-25 22:47:42 +00:00
|
|
|
* appropriate sampling rate.
|
|
|
|
|
*
|
2013-08-26 18:42:21 +00:00
|
|
|
* For CPUs with transition latency > 10ms (mostly drivers with CPUFREQ_ETERNAL)
|
|
|
|
|
* this governor will not work. All times here are in us (micro seconds).
|
2012-10-25 22:47:42 +00:00
|
|
|
*/
|
|
|
|
|
#define MIN_SAMPLING_RATE_RATIO (2)
|
|
|
|
|
#define LATENCY_MULTIPLIER (1000)
|
2013-02-26 09:37:24 +00:00
|
|
|
#define MIN_LATENCY_MULTIPLIER (20)
|
2012-10-25 22:47:42 +00:00
|
|
|
#define TRANSITION_LATENCY_LIMIT (10 * 1000 * 1000)
|
|
|
|
|
|
|
|
|
|
/* Ondemand Sampling types */
|
|
|
|
|
enum {OD_NORMAL_SAMPLE, OD_SUB_SAMPLE};
|
|
|
|
|
|
2013-03-27 15:58:58 +00:00
|
|
|
/* create helper routines */
|
2012-10-25 22:47:42 +00:00
|
|
|
#define define_get_cpu_dbs_routines(_dbs_info) \
|
2015-06-19 11:48:03 +00:00
|
|
|
static struct cpu_dbs_info *get_cpu_cdbs(int cpu) \
|
2012-10-25 22:47:42 +00:00
|
|
|
{ \
|
|
|
|
|
return &per_cpu(_dbs_info, cpu).cdbs; \
|
|
|
|
|
} \
|
|
|
|
|
\
|
|
|
|
|
static void *get_cpu_dbs_info_s(int cpu) \
|
|
|
|
|
{ \
|
|
|
|
|
return &per_cpu(_dbs_info, cpu); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Abbreviations:
|
|
|
|
|
* dbs: used as a shortform for demand based switching It helps to keep variable
|
|
|
|
|
* names smaller, simpler
|
|
|
|
|
* cdbs: common dbs
|
2013-02-28 05:38:00 +00:00
|
|
|
* od_*: On-demand governor
|
2012-10-25 22:47:42 +00:00
|
|
|
* cs_*: Conservative governor
|
|
|
|
|
*/
|
|
|
|
|
|
2016-02-07 15:24:26 +00:00
|
|
|
/* Governor demand based switching data (per-policy or global). */
|
|
|
|
|
struct dbs_data {
|
|
|
|
|
int usage_count;
|
|
|
|
|
void *tuners;
|
2016-02-09 03:31:32 +00:00
|
|
|
unsigned int min_sampling_rate;
|
|
|
|
|
unsigned int ignore_nice_load;
|
|
|
|
|
unsigned int sampling_rate;
|
|
|
|
|
unsigned int sampling_down_factor;
|
|
|
|
|
unsigned int up_threshold;
|
cpufreq: governor: New sysfs show/store callbacks for governor tunables
The ondemand and conservative governors use the global-attr or freq-attr
structures to represent sysfs attributes corresponding to their tunables
(which of them is actually used depends on whether or not different
policy objects can use the same governor with different tunables at the
same time and, consequently, on where those attributes are located in
sysfs).
Unfortunately, in the freq-attr case, the standard cpufreq show/store
sysfs attribute callbacks are applied to the governor tunable attributes
and they always acquire the policy->rwsem lock before carrying out the
operation. That may lead to an ABBA deadlock if governor tunable
attributes are removed under policy->rwsem while one of them is being
accessed concurrently (if sysfs attributes removal wins the race, it
will wait for the access to complete with policy->rwsem held while the
attribute callback will block on policy->rwsem indefinitely).
We attempted to address this issue by dropping policy->rwsem around
governor tunable attributes removal (that is, around invocations of the
->governor callback with the event arg equal to CPUFREQ_GOV_POLICY_EXIT)
in cpufreq_set_policy(), but that opened up race conditions that had not
been possible with policy->rwsem held all the time. Therefore
policy->rwsem cannot be dropped in cpufreq_set_policy() at any point,
but the deadlock situation described above must be avoided too.
To that end, use the observation that in principle governor tunables may
be represented by the same data type regardless of whether the governor
is system-wide or per-policy and introduce a new structure, struct
governor_attr, for representing them and new corresponding macros for
creating show/store sysfs callbacks for them. Also make their parent
kobject use a new kobject type whose default show/store callbacks are
not related to the standard core cpufreq ones in any way (and they don't
acquire policy->rwsem in particular).
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Tested-by: Juri Lelli <juri.lelli@arm.com>
Tested-by: Shilpasri G Bhat <shilpa.bhat@linux.vnet.ibm.com>
[ rjw: Subject & changelog + rebase ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-02-09 03:31:33 +00:00
|
|
|
|
|
|
|
|
struct kobject kobj;
|
2016-02-10 05:30:25 +00:00
|
|
|
struct list_head policy_dbs_list;
|
|
|
|
|
/*
|
|
|
|
|
* Protect concurrent updates to governor tunables from sysfs,
|
|
|
|
|
* policy_dbs_list and usage_count.
|
|
|
|
|
*/
|
cpufreq: governor: New sysfs show/store callbacks for governor tunables
The ondemand and conservative governors use the global-attr or freq-attr
structures to represent sysfs attributes corresponding to their tunables
(which of them is actually used depends on whether or not different
policy objects can use the same governor with different tunables at the
same time and, consequently, on where those attributes are located in
sysfs).
Unfortunately, in the freq-attr case, the standard cpufreq show/store
sysfs attribute callbacks are applied to the governor tunable attributes
and they always acquire the policy->rwsem lock before carrying out the
operation. That may lead to an ABBA deadlock if governor tunable
attributes are removed under policy->rwsem while one of them is being
accessed concurrently (if sysfs attributes removal wins the race, it
will wait for the access to complete with policy->rwsem held while the
attribute callback will block on policy->rwsem indefinitely).
We attempted to address this issue by dropping policy->rwsem around
governor tunable attributes removal (that is, around invocations of the
->governor callback with the event arg equal to CPUFREQ_GOV_POLICY_EXIT)
in cpufreq_set_policy(), but that opened up race conditions that had not
been possible with policy->rwsem held all the time. Therefore
policy->rwsem cannot be dropped in cpufreq_set_policy() at any point,
but the deadlock situation described above must be avoided too.
To that end, use the observation that in principle governor tunables may
be represented by the same data type regardless of whether the governor
is system-wide or per-policy and introduce a new structure, struct
governor_attr, for representing them and new corresponding macros for
creating show/store sysfs callbacks for them. Also make their parent
kobject use a new kobject type whose default show/store callbacks are
not related to the standard core cpufreq ones in any way (and they don't
acquire policy->rwsem in particular).
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Tested-by: Juri Lelli <juri.lelli@arm.com>
Tested-by: Shilpasri G Bhat <shilpa.bhat@linux.vnet.ibm.com>
[ rjw: Subject & changelog + rebase ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-02-09 03:31:33 +00:00
|
|
|
struct mutex mutex;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Governor's specific attributes */
|
|
|
|
|
struct dbs_data;
|
|
|
|
|
struct governor_attr {
|
|
|
|
|
struct attribute attr;
|
|
|
|
|
ssize_t (*show)(struct dbs_data *dbs_data, char *buf);
|
|
|
|
|
ssize_t (*store)(struct dbs_data *dbs_data, const char *buf,
|
|
|
|
|
size_t count);
|
2016-02-07 15:24:26 +00:00
|
|
|
};
|
|
|
|
|
|
cpufreq: governor: New sysfs show/store callbacks for governor tunables
The ondemand and conservative governors use the global-attr or freq-attr
structures to represent sysfs attributes corresponding to their tunables
(which of them is actually used depends on whether or not different
policy objects can use the same governor with different tunables at the
same time and, consequently, on where those attributes are located in
sysfs).
Unfortunately, in the freq-attr case, the standard cpufreq show/store
sysfs attribute callbacks are applied to the governor tunable attributes
and they always acquire the policy->rwsem lock before carrying out the
operation. That may lead to an ABBA deadlock if governor tunable
attributes are removed under policy->rwsem while one of them is being
accessed concurrently (if sysfs attributes removal wins the race, it
will wait for the access to complete with policy->rwsem held while the
attribute callback will block on policy->rwsem indefinitely).
We attempted to address this issue by dropping policy->rwsem around
governor tunable attributes removal (that is, around invocations of the
->governor callback with the event arg equal to CPUFREQ_GOV_POLICY_EXIT)
in cpufreq_set_policy(), but that opened up race conditions that had not
been possible with policy->rwsem held all the time. Therefore
policy->rwsem cannot be dropped in cpufreq_set_policy() at any point,
but the deadlock situation described above must be avoided too.
To that end, use the observation that in principle governor tunables may
be represented by the same data type regardless of whether the governor
is system-wide or per-policy and introduce a new structure, struct
governor_attr, for representing them and new corresponding macros for
creating show/store sysfs callbacks for them. Also make their parent
kobject use a new kobject type whose default show/store callbacks are
not related to the standard core cpufreq ones in any way (and they don't
acquire policy->rwsem in particular).
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Tested-by: Juri Lelli <juri.lelli@arm.com>
Tested-by: Shilpasri G Bhat <shilpa.bhat@linux.vnet.ibm.com>
[ rjw: Subject & changelog + rebase ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-02-09 03:31:33 +00:00
|
|
|
#define gov_show_one(_gov, file_name) \
|
|
|
|
|
static ssize_t show_##file_name \
|
|
|
|
|
(struct dbs_data *dbs_data, char *buf) \
|
|
|
|
|
{ \
|
|
|
|
|
struct _gov##_dbs_tuners *tuners = dbs_data->tuners; \
|
|
|
|
|
return sprintf(buf, "%u\n", tuners->file_name); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define gov_show_one_common(file_name) \
|
|
|
|
|
static ssize_t show_##file_name \
|
|
|
|
|
(struct dbs_data *dbs_data, char *buf) \
|
|
|
|
|
{ \
|
|
|
|
|
return sprintf(buf, "%u\n", dbs_data->file_name); \
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#define gov_attr_ro(_name) \
|
|
|
|
|
static struct governor_attr _name = \
|
|
|
|
|
__ATTR(_name, 0444, show_##_name, NULL)
|
|
|
|
|
|
|
|
|
|
#define gov_attr_rw(_name) \
|
|
|
|
|
static struct governor_attr _name = \
|
|
|
|
|
__ATTR(_name, 0644, show_##_name, store_##_name)
|
|
|
|
|
|
2015-07-18 06:00:59 +00:00
|
|
|
/* Common to all CPUs of a policy */
|
2016-02-10 16:07:44 +00:00
|
|
|
struct policy_dbs_info {
|
2015-07-18 06:00:59 +00:00
|
|
|
struct cpufreq_policy *policy;
|
|
|
|
|
/*
|
2015-12-09 02:04:42 +00:00
|
|
|
* Per policy mutex that serializes load evaluation from limit-change
|
|
|
|
|
* and work-handler.
|
2015-07-18 06:00:59 +00:00
|
|
|
*/
|
|
|
|
|
struct mutex timer_mutex;
|
2015-12-09 02:04:42 +00:00
|
|
|
|
2016-02-10 15:53:50 +00:00
|
|
|
u64 last_sample_time;
|
|
|
|
|
s64 sample_delay_ns;
|
2016-02-08 22:41:10 +00:00
|
|
|
atomic_t work_count;
|
2016-02-10 15:53:50 +00:00
|
|
|
struct irq_work irq_work;
|
2015-12-09 02:04:42 +00:00
|
|
|
struct work_struct work;
|
2016-02-07 15:24:26 +00:00
|
|
|
/* dbs_data may be shared between multiple policy objects */
|
|
|
|
|
struct dbs_data *dbs_data;
|
2016-02-10 05:30:25 +00:00
|
|
|
struct list_head list;
|
2016-02-15 01:13:42 +00:00
|
|
|
/* Status indicators */
|
|
|
|
|
bool is_shared; /* This object is used by multiple CPUs */
|
|
|
|
|
bool work_in_progress; /* Work is being queued up or in progress */
|
2015-07-18 06:00:59 +00:00
|
|
|
};
|
|
|
|
|
|
2016-02-10 16:07:44 +00:00
|
|
|
static inline void gov_update_sample_delay(struct policy_dbs_info *policy_dbs,
|
2016-02-10 15:53:50 +00:00
|
|
|
unsigned int delay_us)
|
|
|
|
|
{
|
2016-02-10 16:07:44 +00:00
|
|
|
policy_dbs->sample_delay_ns = delay_us * NSEC_PER_USEC;
|
2016-02-10 15:53:50 +00:00
|
|
|
}
|
|
|
|
|
|
2012-10-25 22:47:42 +00:00
|
|
|
/* Per cpu structures */
|
2015-06-19 11:48:03 +00:00
|
|
|
struct cpu_dbs_info {
|
2012-10-25 22:51:21 +00:00
|
|
|
u64 prev_cpu_idle;
|
|
|
|
|
u64 prev_cpu_wall;
|
|
|
|
|
u64 prev_cpu_nice;
|
cpufreq: governor: Be friendly towards latency-sensitive bursty workloads
Cpufreq governors like the ondemand governor calculate the load on the CPU
periodically by employing deferrable timers. A deferrable timer won't fire
if the CPU is completely idle (and there are no other timers to be run), in
order to avoid unnecessary wakeups and thus save CPU power.
However, the load calculation logic is agnostic to all this, and this can
lead to the problem described below.
Time (ms) CPU 1
100 Task-A running
110 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
110.5 Task-A running
120 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
125 Task-A went to sleep. With nothing else to do, CPU 1
went completely idle.
200 Task-A woke up and started running again.
200.5 Governor's deferred timer (which was originally programmed
to fire at time 130) fires now. It calculates load for the
time period 120 to 200.5, and finds the load is almost zero.
Hence it decreases the CPU frequency to the minimum.
210 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
So, after the workload woke up and started running, the frequency was suddenly
dropped to absolute minimum, and after that, there was an unnecessary delay of
10ms (sampling period) to increase the CPU frequency back to a reasonable value.
And this pattern repeats for every wake-up-from-cpu-idle for that workload.
This can be quite undesirable for latency- or response-time sensitive bursty
workloads. So we need to fix the governor's logic to detect such wake-up-from-
cpu-idle scenarios and start the workload at a reasonably high CPU frequency.
One extreme solution would be to fake a load of 100% in such scenarios. But
that might lead to undesirable side-effects such as frequency spikes (which
might also need voltage changes) especially if the previous frequency happened
to be very low.
We just want to avoid the stupidity of dropping down the frequency to a minimum
and then enduring a needless (and long) delay before ramping it up back again.
So, let us simply carry forward the previous load - that is, let us just pretend
that the 'load' for the current time-window is the same as the load for the
previous window. That way, the frequency and voltage will continue to be set
to whatever values they were set at previously. This means that bursty workloads
will get a chance to influence the CPU frequency at which they wake up from
cpu-idle, based on their past execution history. Thus, they might be able to
avoid suffering from slow wakeups and long response-times.
However, we should take care not to over-do this. For example, such a "copy
previous load" logic will benefit cases like this: (where # represents busy
and . represents idle)
##########.........#########.........###########...........##########........
but it will be detrimental in cases like the one shown below, because it will
retain the high frequency (copied from the previous interval) even in a mostly
idle system:
##########.........#.................#.....................#...............
(i.e., the workload finished and the remaining tasks are such that their busy
periods are smaller than the sampling interval, which causes the timer to
always get deferred. So, this will make the copy-previous-load logic copy
the initial high load to subsequent idle periods over and over again, thus
keeping the frequency high unnecessarily).
So, we modify this copy-previous-load logic such that it is used only once
upon every wakeup-from-idle. Thus if we have 2 consecutive idle periods, the
previous load won't get blindly copied over; cpufreq will freshly evaluate the
load in the second idle interval, thus ensuring that the system comes back to
its normal state.
[ The right way to solve this whole problem is to teach the CPU frequency
governors to also track load on a per-task basis, not just a per-CPU basis,
and then use both the data sources intelligently to set the appropriate
frequency on the CPUs. But that involves redesigning the cpufreq subsystem,
so this patch should make the situation bearable until then. ]
Experimental results:
+-------------------+
I ran a modified version of ebizzy (called 'sleeping-ebizzy') that sleeps in
between its execution such that its total utilization can be a user-defined
value, say 10% or 20% (higher the utilization specified, lesser the amount of
sleeps injected). This ebizzy was run with a single-thread, tied to CPU 8.
Behavior observed with tracing (sample taken from 40% utilization runs):
------------------------------------------------------------------------
Without patch:
~~~~~~~~~~~~~~
kworker/8:2-12137 416.335742: cpu_frequency: state=2061000 cpu_id=8
kworker/8:2-12137 416.335744: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.345741: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.345744: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-12137 416.345746: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.355738: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
<snip> --------------------------------------------------------------------- <snip>
<...>-40753 416.402202: sched_switch: prev_comm=ebizzy ==> next_comm=swapper/8
<idle>-0 416.502130: sched_switch: prev_comm=swapper/8 ==> next_comm=ebizzy
<...>-40753 416.505738: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.505739: cpu_frequency: state=2061000 cpu_id=8
kworker/8:2-12137 416.505741: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.515739: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.515742: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-12137 416.515744: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
Observation: Ebizzy went idle at 416.402202, and started running again at
416.502130. But cpufreq noticed the long idle period, and dropped the frequency
at 416.505739, only to increase it back again at 416.515742, realizing that the
workload is in-fact CPU bound. Thus ebizzy needlessly ran at the lowest frequency
for almost 13 milliseconds (almost 1 full sample period), and this pattern
repeats on every sleep-wakeup. This could hurt latency-sensitive workloads quite
a lot.
With patch:
~~~~~~~~~~~
kworker/8:2-29802 464.832535: cpu_frequency: state=2061000 cpu_id=8
<snip> --------------------------------------------------------------------- <snip>
kworker/8:2-29802 464.962538: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 464.972533: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 464.972536: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-29802 464.972538: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 464.982531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
<snip> --------------------------------------------------------------------- <snip>
kworker/8:2-29802 465.022533: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.032531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 465.032532: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.035797: sched_switch: prev_comm=ebizzy ==> next_comm=swapper/8
<idle>-0 465.240178: sched_switch: prev_comm=swapper/8 ==> next_comm=ebizzy
<...>-40738 465.242533: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 465.242535: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.252531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
Observation: Ebizzy went idle at 465.035797, and started running again at
465.240178. Since ebizzy was the only real workload running on this CPU,
cpufreq retained the frequency at 4.1Ghz throughout the run of ebizzy, no
matter how many times ebizzy slept and woke-up in-between. Thus, ebizzy
got the 10ms worth of 4.1 Ghz benefit during every sleep-wakeup (as compared
to the run without the patch) and this boost gave a modest improvement in total
throughput, as shown below.
Sleeping-ebizzy records-per-second:
-----------------------------------
Utilization Without patch With patch Difference (Absolute and % values)
10% 274767 277046 + 2279 (+0.829%)
20% 543429 553484 + 10055 (+1.850%)
40% 1090744 1107959 + 17215 (+1.578%)
60% 1634908 1662018 + 27110 (+1.658%)
A rudimentary and somewhat approximately latency-sensitive workload such as
sleeping-ebizzy itself showed a consistent, noticeable performance improvement
with this patch. Hence, workloads that are truly latency-sensitive will benefit
quite a bit from this change. Moreover, this is an overall win-win since this
patch does not hurt power-savings at all (because, this patch does not reduce
the idle time or idle residency; and the high frequency of the CPU when it goes
to cpu-idle does not affect/hurt the power-savings of deep idle states).
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Reviewed-by: Gautham R. Shenoy <ego@linux.vnet.ibm.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-06-07 20:41:43 +00:00
|
|
|
/*
|
2014-06-09 08:51:24 +00:00
|
|
|
* Used to keep track of load in the previous interval. However, when
|
|
|
|
|
* explicitly set to zero, it is used as a flag to ensure that we copy
|
|
|
|
|
* the previous load to the current interval only once, upon the first
|
|
|
|
|
* wake-up from idle.
|
cpufreq: governor: Be friendly towards latency-sensitive bursty workloads
Cpufreq governors like the ondemand governor calculate the load on the CPU
periodically by employing deferrable timers. A deferrable timer won't fire
if the CPU is completely idle (and there are no other timers to be run), in
order to avoid unnecessary wakeups and thus save CPU power.
However, the load calculation logic is agnostic to all this, and this can
lead to the problem described below.
Time (ms) CPU 1
100 Task-A running
110 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
110.5 Task-A running
120 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
125 Task-A went to sleep. With nothing else to do, CPU 1
went completely idle.
200 Task-A woke up and started running again.
200.5 Governor's deferred timer (which was originally programmed
to fire at time 130) fires now. It calculates load for the
time period 120 to 200.5, and finds the load is almost zero.
Hence it decreases the CPU frequency to the minimum.
210 Governor's timer fires, finds load as 100% in the last
10ms interval and increases the CPU frequency.
So, after the workload woke up and started running, the frequency was suddenly
dropped to absolute minimum, and after that, there was an unnecessary delay of
10ms (sampling period) to increase the CPU frequency back to a reasonable value.
And this pattern repeats for every wake-up-from-cpu-idle for that workload.
This can be quite undesirable for latency- or response-time sensitive bursty
workloads. So we need to fix the governor's logic to detect such wake-up-from-
cpu-idle scenarios and start the workload at a reasonably high CPU frequency.
One extreme solution would be to fake a load of 100% in such scenarios. But
that might lead to undesirable side-effects such as frequency spikes (which
might also need voltage changes) especially if the previous frequency happened
to be very low.
We just want to avoid the stupidity of dropping down the frequency to a minimum
and then enduring a needless (and long) delay before ramping it up back again.
So, let us simply carry forward the previous load - that is, let us just pretend
that the 'load' for the current time-window is the same as the load for the
previous window. That way, the frequency and voltage will continue to be set
to whatever values they were set at previously. This means that bursty workloads
will get a chance to influence the CPU frequency at which they wake up from
cpu-idle, based on their past execution history. Thus, they might be able to
avoid suffering from slow wakeups and long response-times.
However, we should take care not to over-do this. For example, such a "copy
previous load" logic will benefit cases like this: (where # represents busy
and . represents idle)
##########.........#########.........###########...........##########........
but it will be detrimental in cases like the one shown below, because it will
retain the high frequency (copied from the previous interval) even in a mostly
idle system:
##########.........#.................#.....................#...............
(i.e., the workload finished and the remaining tasks are such that their busy
periods are smaller than the sampling interval, which causes the timer to
always get deferred. So, this will make the copy-previous-load logic copy
the initial high load to subsequent idle periods over and over again, thus
keeping the frequency high unnecessarily).
So, we modify this copy-previous-load logic such that it is used only once
upon every wakeup-from-idle. Thus if we have 2 consecutive idle periods, the
previous load won't get blindly copied over; cpufreq will freshly evaluate the
load in the second idle interval, thus ensuring that the system comes back to
its normal state.
[ The right way to solve this whole problem is to teach the CPU frequency
governors to also track load on a per-task basis, not just a per-CPU basis,
and then use both the data sources intelligently to set the appropriate
frequency on the CPUs. But that involves redesigning the cpufreq subsystem,
so this patch should make the situation bearable until then. ]
Experimental results:
+-------------------+
I ran a modified version of ebizzy (called 'sleeping-ebizzy') that sleeps in
between its execution such that its total utilization can be a user-defined
value, say 10% or 20% (higher the utilization specified, lesser the amount of
sleeps injected). This ebizzy was run with a single-thread, tied to CPU 8.
Behavior observed with tracing (sample taken from 40% utilization runs):
------------------------------------------------------------------------
Without patch:
~~~~~~~~~~~~~~
kworker/8:2-12137 416.335742: cpu_frequency: state=2061000 cpu_id=8
kworker/8:2-12137 416.335744: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.345741: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.345744: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-12137 416.345746: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.355738: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
<snip> --------------------------------------------------------------------- <snip>
<...>-40753 416.402202: sched_switch: prev_comm=ebizzy ==> next_comm=swapper/8
<idle>-0 416.502130: sched_switch: prev_comm=swapper/8 ==> next_comm=ebizzy
<...>-40753 416.505738: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.505739: cpu_frequency: state=2061000 cpu_id=8
kworker/8:2-12137 416.505741: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40753 416.515739: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-12137 416.515742: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-12137 416.515744: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
Observation: Ebizzy went idle at 416.402202, and started running again at
416.502130. But cpufreq noticed the long idle period, and dropped the frequency
at 416.505739, only to increase it back again at 416.515742, realizing that the
workload is in-fact CPU bound. Thus ebizzy needlessly ran at the lowest frequency
for almost 13 milliseconds (almost 1 full sample period), and this pattern
repeats on every sleep-wakeup. This could hurt latency-sensitive workloads quite
a lot.
With patch:
~~~~~~~~~~~
kworker/8:2-29802 464.832535: cpu_frequency: state=2061000 cpu_id=8
<snip> --------------------------------------------------------------------- <snip>
kworker/8:2-29802 464.962538: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 464.972533: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 464.972536: cpu_frequency: state=4123000 cpu_id=8
kworker/8:2-29802 464.972538: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 464.982531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
<snip> --------------------------------------------------------------------- <snip>
kworker/8:2-29802 465.022533: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.032531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 465.032532: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.035797: sched_switch: prev_comm=ebizzy ==> next_comm=swapper/8
<idle>-0 465.240178: sched_switch: prev_comm=swapper/8 ==> next_comm=ebizzy
<...>-40738 465.242533: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
kworker/8:2-29802 465.242535: sched_switch: prev_comm=kworker/8:2 ==> next_comm=ebizzy
<...>-40738 465.252531: sched_switch: prev_comm=ebizzy ==> next_comm=kworker/8:2
Observation: Ebizzy went idle at 465.035797, and started running again at
465.240178. Since ebizzy was the only real workload running on this CPU,
cpufreq retained the frequency at 4.1Ghz throughout the run of ebizzy, no
matter how many times ebizzy slept and woke-up in-between. Thus, ebizzy
got the 10ms worth of 4.1 Ghz benefit during every sleep-wakeup (as compared
to the run without the patch) and this boost gave a modest improvement in total
throughput, as shown below.
Sleeping-ebizzy records-per-second:
-----------------------------------
Utilization Without patch With patch Difference (Absolute and % values)
10% 274767 277046 + 2279 (+0.829%)
20% 543429 553484 + 10055 (+1.850%)
40% 1090744 1107959 + 17215 (+1.578%)
60% 1634908 1662018 + 27110 (+1.658%)
A rudimentary and somewhat approximately latency-sensitive workload such as
sleeping-ebizzy itself showed a consistent, noticeable performance improvement
with this patch. Hence, workloads that are truly latency-sensitive will benefit
quite a bit from this change. Moreover, this is an overall win-win since this
patch does not hurt power-savings at all (because, this patch does not reduce
the idle time or idle residency; and the high frequency of the CPU when it goes
to cpu-idle does not affect/hurt the power-savings of deep idle states).
Signed-off-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>
Reviewed-by: Gautham R. Shenoy <ego@linux.vnet.ibm.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2014-06-07 20:41:43 +00:00
|
|
|
*/
|
2014-06-09 08:51:24 +00:00
|
|
|
unsigned int prev_load;
|
2016-02-10 15:53:50 +00:00
|
|
|
struct update_util_data update_util;
|
2016-02-10 16:07:44 +00:00
|
|
|
struct policy_dbs_info *policy_dbs;
|
2012-10-25 22:47:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct od_cpu_dbs_info_s {
|
2015-06-19 11:48:03 +00:00
|
|
|
struct cpu_dbs_info cdbs;
|
2012-10-25 22:47:42 +00:00
|
|
|
struct cpufreq_frequency_table *freq_table;
|
|
|
|
|
unsigned int freq_lo;
|
|
|
|
|
unsigned int freq_lo_jiffies;
|
|
|
|
|
unsigned int freq_hi_jiffies;
|
|
|
|
|
unsigned int rate_mult;
|
|
|
|
|
unsigned int sample_type:1;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cs_cpu_dbs_info_s {
|
2015-06-19 11:48:03 +00:00
|
|
|
struct cpu_dbs_info cdbs;
|
2012-10-25 22:47:42 +00:00
|
|
|
unsigned int down_skip;
|
|
|
|
|
unsigned int requested_freq;
|
|
|
|
|
};
|
|
|
|
|
|
2013-08-26 18:42:21 +00:00
|
|
|
/* Per policy Governors sysfs tunables */
|
2012-10-25 22:47:42 +00:00
|
|
|
struct od_dbs_tuners {
|
|
|
|
|
unsigned int powersave_bias;
|
|
|
|
|
unsigned int io_is_busy;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct cs_dbs_tuners {
|
|
|
|
|
unsigned int down_threshold;
|
|
|
|
|
unsigned int freq_step;
|
|
|
|
|
};
|
|
|
|
|
|
2013-08-26 18:42:21 +00:00
|
|
|
/* Common Governor data across policies */
|
2016-02-07 15:05:07 +00:00
|
|
|
struct dbs_governor {
|
2016-02-05 02:16:08 +00:00
|
|
|
struct cpufreq_governor gov;
|
|
|
|
|
|
2012-10-25 22:47:42 +00:00
|
|
|
#define GOV_ONDEMAND 0
|
|
|
|
|
#define GOV_CONSERVATIVE 1
|
|
|
|
|
int governor;
|
cpufreq: governor: New sysfs show/store callbacks for governor tunables
The ondemand and conservative governors use the global-attr or freq-attr
structures to represent sysfs attributes corresponding to their tunables
(which of them is actually used depends on whether or not different
policy objects can use the same governor with different tunables at the
same time and, consequently, on where those attributes are located in
sysfs).
Unfortunately, in the freq-attr case, the standard cpufreq show/store
sysfs attribute callbacks are applied to the governor tunable attributes
and they always acquire the policy->rwsem lock before carrying out the
operation. That may lead to an ABBA deadlock if governor tunable
attributes are removed under policy->rwsem while one of them is being
accessed concurrently (if sysfs attributes removal wins the race, it
will wait for the access to complete with policy->rwsem held while the
attribute callback will block on policy->rwsem indefinitely).
We attempted to address this issue by dropping policy->rwsem around
governor tunable attributes removal (that is, around invocations of the
->governor callback with the event arg equal to CPUFREQ_GOV_POLICY_EXIT)
in cpufreq_set_policy(), but that opened up race conditions that had not
been possible with policy->rwsem held all the time. Therefore
policy->rwsem cannot be dropped in cpufreq_set_policy() at any point,
but the deadlock situation described above must be avoided too.
To that end, use the observation that in principle governor tunables may
be represented by the same data type regardless of whether the governor
is system-wide or per-policy and introduce a new structure, struct
governor_attr, for representing them and new corresponding macros for
creating show/store sysfs callbacks for them. Also make their parent
kobject use a new kobject type whose default show/store callbacks are
not related to the standard core cpufreq ones in any way (and they don't
acquire policy->rwsem in particular).
Signed-off-by: Viresh Kumar <viresh.kumar@linaro.org>
Tested-by: Juri Lelli <juri.lelli@arm.com>
Tested-by: Shilpasri G Bhat <shilpa.bhat@linux.vnet.ibm.com>
[ rjw: Subject & changelog + rebase ]
Signed-off-by: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
2016-02-09 03:31:33 +00:00
|
|
|
struct kobj_type kobj_type;
|
2012-10-25 22:47:42 +00:00
|
|
|
|
2013-10-02 08:43:18 +00:00
|
|
|
/*
|
|
|
|
|
* Common data for platforms that don't set
|
|
|
|
|
* CPUFREQ_HAVE_GOVERNOR_PER_POLICY
|
|
|
|
|
*/
|
2013-03-27 15:58:58 +00:00
|
|
|
struct dbs_data *gdbs_data;
|
2012-10-25 22:47:42 +00:00
|
|
|
|
2015-06-19 11:48:03 +00:00
|
|
|
struct cpu_dbs_info *(*get_cpu_cdbs)(int cpu);
|
2012-10-25 22:47:42 +00:00
|
|
|
void *(*get_cpu_dbs_info_s)(int cpu);
|
2016-02-10 15:53:50 +00:00
|
|
|
unsigned int (*gov_dbs_timer)(struct cpufreq_policy *policy);
|
2012-10-25 22:47:42 +00:00
|
|
|
void (*gov_check_cpu)(int cpu, unsigned int load);
|
2015-06-03 10:27:11 +00:00
|
|
|
int (*init)(struct dbs_data *dbs_data, bool notify);
|
|
|
|
|
void (*exit)(struct dbs_data *dbs_data, bool notify);
|
2012-10-25 22:47:42 +00:00
|
|
|
|
|
|
|
|
/* Governor specific ops, see below */
|
|
|
|
|
void *gov_ops;
|
|
|
|
|
};
|
|
|
|
|
|
2016-02-07 15:09:51 +00:00
|
|
|
static inline struct dbs_governor *dbs_governor_of(struct cpufreq_policy *policy)
|
|
|
|
|
{
|
|
|
|
|
return container_of(policy->governor, struct dbs_governor, gov);
|
|
|
|
|
}
|
|
|
|
|
|
2012-10-25 22:47:42 +00:00
|
|
|
/* Governor specific ops, will be passed to dbs_data->gov_ops */
|
|
|
|
|
struct od_ops {
|
|
|
|
|
void (*powersave_bias_init_cpu)(int cpu);
|
|
|
|
|
unsigned int (*powersave_bias_target)(struct cpufreq_policy *policy,
|
|
|
|
|
unsigned int freq_next, unsigned int relation);
|
2013-08-06 17:23:05 +00:00
|
|
|
void (*freq_increase)(struct cpufreq_policy *policy, unsigned int freq);
|
2012-10-25 22:47:42 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline int delay_for_sampling_rate(unsigned int sampling_rate)
|
|
|
|
|
{
|
|
|
|
|
int delay = usecs_to_jiffies(sampling_rate);
|
|
|
|
|
|
|
|
|
|
/* We want all CPUs to do sampling nearly on same jiffy */
|
|
|
|
|
if (num_online_cpus() > 1)
|
|
|
|
|
delay -= jiffies % delay;
|
|
|
|
|
|
|
|
|
|
return delay;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-07 15:01:31 +00:00
|
|
|
extern struct mutex dbs_data_mutex;
|
2016-02-06 12:50:24 +00:00
|
|
|
void dbs_check_cpu(struct cpufreq_policy *policy);
|
2016-02-07 15:07:51 +00:00
|
|
|
int cpufreq_governor_dbs(struct cpufreq_policy *policy, unsigned int event);
|
2013-04-02 14:56:56 +00:00
|
|
|
void od_register_powersave_bias_handler(unsigned int (*f)
|
|
|
|
|
(struct cpufreq_policy *, unsigned int, unsigned int),
|
|
|
|
|
unsigned int powersave_bias);
|
|
|
|
|
void od_unregister_powersave_bias_handler(void);
|
2016-02-11 12:01:15 +00:00
|
|
|
ssize_t store_sampling_rate(struct dbs_data *dbs_data, const char *buf,
|
|
|
|
|
size_t count);
|
2013-04-02 12:26:15 +00:00
|
|
|
#endif /* _CPUFREQ_GOVERNOR_H */
|
