2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
#include <linux/sched.h>
|
2013-02-07 15:46:59 +00:00
|
|
|
#include <linux/sched/sysctl.h>
|
2013-02-07 15:47:07 +00:00
|
|
|
#include <linux/sched/rt.h>
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
#include <linux/sched/deadline.h>
|
2011-10-25 08:00:11 +00:00
|
|
|
#include <linux/mutex.h>
|
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
|
#include <linux/stop_machine.h>
|
2013-04-20 12:35:09 +00:00
|
|
|
#include <linux/tick.h>
|
2013-10-07 10:28:57 +00:00
|
|
|
#include <linux/slab.h>
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2011-11-15 16:14:39 +00:00
|
|
|
#include "cpupri.h"
|
2013-11-07 13:43:47 +00:00
|
|
|
#include "cpudeadline.h"
|
2013-03-29 06:36:43 +00:00
|
|
|
#include "cpuacct.h"
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-04-19 19:10:49 +00:00
|
|
|
struct rq;
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
extern __read_mostly int scheduler_running;
|
|
|
|
|
|
2013-04-19 19:10:49 +00:00
|
|
|
extern unsigned long calc_load_update;
|
|
|
|
|
extern atomic_long_t calc_load_tasks;
|
|
|
|
|
|
|
|
|
|
extern long calc_load_fold_active(struct rq *this_rq);
|
|
|
|
|
extern void update_cpu_load_active(struct rq *this_rq);
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* Helpers for converting nanosecond timing to jiffy resolution
|
|
|
|
|
*/
|
|
|
|
|
#define NS_TO_JIFFIES(TIME) ((unsigned long)(TIME) / (NSEC_PER_SEC / HZ))
|
|
|
|
|
|
2013-03-05 08:06:09 +00:00
|
|
|
/*
|
|
|
|
|
* Increase resolution of nice-level calculations for 64-bit architectures.
|
|
|
|
|
* The extra resolution improves shares distribution and load balancing of
|
|
|
|
|
* low-weight task groups (eg. nice +19 on an autogroup), deeper taskgroup
|
|
|
|
|
* hierarchies, especially on larger systems. This is not a user-visible change
|
|
|
|
|
* and does not change the user-interface for setting shares/weights.
|
|
|
|
|
*
|
|
|
|
|
* We increase resolution only if we have enough bits to allow this increased
|
|
|
|
|
* resolution (i.e. BITS_PER_LONG > 32). The costs for increasing resolution
|
|
|
|
|
* when BITS_PER_LONG <= 32 are pretty high and the returns do not justify the
|
|
|
|
|
* increased costs.
|
|
|
|
|
*/
|
|
|
|
|
#if 0 /* BITS_PER_LONG > 32 -- currently broken: it increases power usage under light load */
|
|
|
|
|
# define SCHED_LOAD_RESOLUTION 10
|
|
|
|
|
# define scale_load(w) ((w) << SCHED_LOAD_RESOLUTION)
|
|
|
|
|
# define scale_load_down(w) ((w) >> SCHED_LOAD_RESOLUTION)
|
|
|
|
|
#else
|
|
|
|
|
# define SCHED_LOAD_RESOLUTION 0
|
|
|
|
|
# define scale_load(w) (w)
|
|
|
|
|
# define scale_load_down(w) (w)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define SCHED_LOAD_SHIFT (10 + SCHED_LOAD_RESOLUTION)
|
|
|
|
|
#define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT)
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#define NICE_0_LOAD SCHED_LOAD_SCALE
|
|
|
|
|
#define NICE_0_SHIFT SCHED_LOAD_SHIFT
|
|
|
|
|
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
/*
|
|
|
|
|
* Single value that decides SCHED_DEADLINE internal math precision.
|
|
|
|
|
* 10 -> just above 1us
|
|
|
|
|
* 9 -> just above 0.5us
|
|
|
|
|
*/
|
|
|
|
|
#define DL_SCALE (10)
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* These are the 'tuning knobs' of the scheduler:
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* single value that denotes runtime == period, ie unlimited time.
|
|
|
|
|
*/
|
|
|
|
|
#define RUNTIME_INF ((u64)~0ULL)
|
|
|
|
|
|
sched: Add new scheduler syscalls to support an extended scheduling parameters ABI
Add the syscalls needed for supporting scheduling algorithms
with extended scheduling parameters (e.g., SCHED_DEADLINE).
In general, it makes possible to specify a periodic/sporadic task,
that executes for a given amount of runtime at each instance, and is
scheduled according to the urgency of their own timing constraints,
i.e.:
- a (maximum/typical) instance execution time,
- a minimum interval between consecutive instances,
- a time constraint by which each instance must be completed.
Thus, both the data structure that holds the scheduling parameters of
the tasks and the system calls dealing with it must be extended.
Unfortunately, modifying the existing struct sched_param would break
the ABI and result in potentially serious compatibility issues with
legacy binaries.
For these reasons, this patch:
- defines the new struct sched_attr, containing all the fields
that are necessary for specifying a task in the computational
model described above;
- defines and implements the new scheduling related syscalls that
manipulate it, i.e., sched_setattr() and sched_getattr().
Syscalls are introduced for x86 (32 and 64 bits) and ARM only, as a
proof of concept and for developing and testing purposes. Making them
available on other architectures is straightforward.
Since no "user" for these new parameters is introduced in this patch,
the implementation of the new system calls is just identical to their
already existing counterpart. Future patches that implement scheduling
policies able to exploit the new data structure must also take care of
modifying the sched_*attr() calls accordingly with their own purposes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
[ Rewrote to use sched_attr. ]
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
[ Removed sched_setscheduler2() for now. ]
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-3-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:36 +00:00
|
|
|
static inline int fair_policy(int policy)
|
|
|
|
|
{
|
|
|
|
|
return policy == SCHED_NORMAL || policy == SCHED_BATCH;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static inline int rt_policy(int policy)
|
|
|
|
|
{
|
sched: Add new scheduler syscalls to support an extended scheduling parameters ABI
Add the syscalls needed for supporting scheduling algorithms
with extended scheduling parameters (e.g., SCHED_DEADLINE).
In general, it makes possible to specify a periodic/sporadic task,
that executes for a given amount of runtime at each instance, and is
scheduled according to the urgency of their own timing constraints,
i.e.:
- a (maximum/typical) instance execution time,
- a minimum interval between consecutive instances,
- a time constraint by which each instance must be completed.
Thus, both the data structure that holds the scheduling parameters of
the tasks and the system calls dealing with it must be extended.
Unfortunately, modifying the existing struct sched_param would break
the ABI and result in potentially serious compatibility issues with
legacy binaries.
For these reasons, this patch:
- defines the new struct sched_attr, containing all the fields
that are necessary for specifying a task in the computational
model described above;
- defines and implements the new scheduling related syscalls that
manipulate it, i.e., sched_setattr() and sched_getattr().
Syscalls are introduced for x86 (32 and 64 bits) and ARM only, as a
proof of concept and for developing and testing purposes. Making them
available on other architectures is straightforward.
Since no "user" for these new parameters is introduced in this patch,
the implementation of the new system calls is just identical to their
already existing counterpart. Future patches that implement scheduling
policies able to exploit the new data structure must also take care of
modifying the sched_*attr() calls accordingly with their own purposes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
[ Rewrote to use sched_attr. ]
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
[ Removed sched_setscheduler2() for now. ]
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-3-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:36 +00:00
|
|
|
return policy == SCHED_FIFO || policy == SCHED_RR;
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
static inline int dl_policy(int policy)
|
|
|
|
|
{
|
|
|
|
|
return policy == SCHED_DEADLINE;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static inline int task_has_rt_policy(struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
return rt_policy(p->policy);
|
|
|
|
|
}
|
|
|
|
|
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
static inline int task_has_dl_policy(struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
return dl_policy(p->policy);
|
|
|
|
|
}
|
|
|
|
|
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
static inline bool dl_time_before(u64 a, u64 b)
|
sched/deadline: Add SCHED_DEADLINE inheritance logic
Some method to deal with rt-mutexes and make sched_dl interact with
the current PI-coded is needed, raising all but trivial issues, that
needs (according to us) to be solved with some restructuring of
the pi-code (i.e., going toward a proxy execution-ish implementation).
This is under development, in the meanwhile, as a temporary solution,
what this commits does is:
- ensure a pi-lock owner with waiters is never throttled down. Instead,
when it runs out of runtime, it immediately gets replenished and it's
deadline is postponed;
- the scheduling parameters (relative deadline and default runtime)
used for that replenishments --during the whole period it holds the
pi-lock-- are the ones of the waiting task with earliest deadline.
Acting this way, we provide some kind of boosting to the lock-owner,
still by using the existing (actually, slightly modified by the previous
commit) pi-architecture.
We would stress the fact that this is only a surely needed, all but
clean solution to the problem. In the end it's only a way to re-start
discussion within the community. So, as always, comments, ideas, rants,
etc.. are welcome! :-)
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
[ Added !RT_MUTEXES build fix. ]
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-11-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:44 +00:00
|
|
|
{
|
|
|
|
|
return (s64)(a - b) < 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tells if entity @a should preempt entity @b.
|
|
|
|
|
*/
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
static inline bool
|
|
|
|
|
dl_entity_preempt(struct sched_dl_entity *a, struct sched_dl_entity *b)
|
sched/deadline: Add SCHED_DEADLINE inheritance logic
Some method to deal with rt-mutexes and make sched_dl interact with
the current PI-coded is needed, raising all but trivial issues, that
needs (according to us) to be solved with some restructuring of
the pi-code (i.e., going toward a proxy execution-ish implementation).
This is under development, in the meanwhile, as a temporary solution,
what this commits does is:
- ensure a pi-lock owner with waiters is never throttled down. Instead,
when it runs out of runtime, it immediately gets replenished and it's
deadline is postponed;
- the scheduling parameters (relative deadline and default runtime)
used for that replenishments --during the whole period it holds the
pi-lock-- are the ones of the waiting task with earliest deadline.
Acting this way, we provide some kind of boosting to the lock-owner,
still by using the existing (actually, slightly modified by the previous
commit) pi-architecture.
We would stress the fact that this is only a surely needed, all but
clean solution to the problem. In the end it's only a way to re-start
discussion within the community. So, as always, comments, ideas, rants,
etc.. are welcome! :-)
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
[ Added !RT_MUTEXES build fix. ]
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-11-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:44 +00:00
|
|
|
{
|
|
|
|
|
return dl_time_before(a->deadline, b->deadline);
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* This is the priority-queue data structure of the RT scheduling class:
|
|
|
|
|
*/
|
|
|
|
|
struct rt_prio_array {
|
|
|
|
|
DECLARE_BITMAP(bitmap, MAX_RT_PRIO+1); /* include 1 bit for delimiter */
|
|
|
|
|
struct list_head queue[MAX_RT_PRIO];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct rt_bandwidth {
|
|
|
|
|
/* nests inside the rq lock: */
|
|
|
|
|
raw_spinlock_t rt_runtime_lock;
|
|
|
|
|
ktime_t rt_period;
|
|
|
|
|
u64 rt_runtime;
|
|
|
|
|
struct hrtimer rt_period_timer;
|
|
|
|
|
};
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
/*
|
|
|
|
|
* To keep the bandwidth of -deadline tasks and groups under control
|
|
|
|
|
* we need some place where:
|
|
|
|
|
* - store the maximum -deadline bandwidth of the system (the group);
|
|
|
|
|
* - cache the fraction of that bandwidth that is currently allocated.
|
|
|
|
|
*
|
|
|
|
|
* This is all done in the data structure below. It is similar to the
|
|
|
|
|
* one used for RT-throttling (rt_bandwidth), with the main difference
|
|
|
|
|
* that, since here we are only interested in admission control, we
|
|
|
|
|
* do not decrease any runtime while the group "executes", neither we
|
|
|
|
|
* need a timer to replenish it.
|
|
|
|
|
*
|
|
|
|
|
* With respect to SMP, the bandwidth is given on a per-CPU basis,
|
|
|
|
|
* meaning that:
|
|
|
|
|
* - dl_bw (< 100%) is the bandwidth of the system (group) on each CPU;
|
|
|
|
|
* - dl_total_bw array contains, in the i-eth element, the currently
|
|
|
|
|
* allocated bandwidth on the i-eth CPU.
|
|
|
|
|
* Moreover, groups consume bandwidth on each CPU, while tasks only
|
|
|
|
|
* consume bandwidth on the CPU they're running on.
|
|
|
|
|
* Finally, dl_total_bw_cpu is used to cache the index of dl_total_bw
|
|
|
|
|
* that will be shown the next time the proc or cgroup controls will
|
|
|
|
|
* be red. It on its turn can be changed by writing on its own
|
|
|
|
|
* control.
|
|
|
|
|
*/
|
|
|
|
|
struct dl_bandwidth {
|
|
|
|
|
raw_spinlock_t dl_runtime_lock;
|
|
|
|
|
u64 dl_runtime;
|
|
|
|
|
u64 dl_period;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline int dl_bandwidth_enabled(void)
|
|
|
|
|
{
|
2013-12-17 11:44:49 +00:00
|
|
|
return sysctl_sched_rt_runtime >= 0;
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern struct dl_bw *dl_bw_of(int i);
|
|
|
|
|
|
|
|
|
|
struct dl_bw {
|
|
|
|
|
raw_spinlock_t lock;
|
|
|
|
|
u64 bw, total_bw;
|
|
|
|
|
};
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
extern struct mutex sched_domains_mutex;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
|
|
|
|
|
|
|
|
|
#include <linux/cgroup.h>
|
|
|
|
|
|
|
|
|
|
struct cfs_rq;
|
|
|
|
|
struct rt_rq;
|
|
|
|
|
|
2012-08-07 03:00:13 +00:00
|
|
|
extern struct list_head task_groups;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
struct cfs_bandwidth {
|
|
|
|
|
#ifdef CONFIG_CFS_BANDWIDTH
|
|
|
|
|
raw_spinlock_t lock;
|
|
|
|
|
ktime_t period;
|
|
|
|
|
u64 quota, runtime;
|
|
|
|
|
s64 hierarchal_quota;
|
|
|
|
|
u64 runtime_expires;
|
|
|
|
|
|
|
|
|
|
int idle, timer_active;
|
|
|
|
|
struct hrtimer period_timer, slack_timer;
|
|
|
|
|
struct list_head throttled_cfs_rq;
|
|
|
|
|
|
|
|
|
|
/* statistics */
|
|
|
|
|
int nr_periods, nr_throttled;
|
|
|
|
|
u64 throttled_time;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* task group related information */
|
|
|
|
|
struct task_group {
|
|
|
|
|
struct cgroup_subsys_state css;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
/* schedulable entities of this group on each cpu */
|
|
|
|
|
struct sched_entity **se;
|
|
|
|
|
/* runqueue "owned" by this group on each cpu */
|
|
|
|
|
struct cfs_rq **cfs_rq;
|
|
|
|
|
unsigned long shares;
|
|
|
|
|
|
2013-06-20 02:18:46 +00:00
|
|
|
#ifdef CONFIG_SMP
|
2013-06-20 02:18:54 +00:00
|
|
|
atomic_long_t load_avg;
|
2012-10-04 11:18:31 +00:00
|
|
|
atomic_t runnable_avg;
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif
|
2013-06-20 02:18:46 +00:00
|
|
|
#endif
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
|
struct sched_rt_entity **rt_se;
|
|
|
|
|
struct rt_rq **rt_rq;
|
|
|
|
|
|
|
|
|
|
struct rt_bandwidth rt_bandwidth;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct rcu_head rcu;
|
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
|
|
struct task_group *parent;
|
|
|
|
|
struct list_head siblings;
|
|
|
|
|
struct list_head children;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_AUTOGROUP
|
|
|
|
|
struct autogroup *autogroup;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct cfs_bandwidth cfs_bandwidth;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
#define ROOT_TASK_GROUP_LOAD NICE_0_LOAD
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* A weight of 0 or 1 can cause arithmetics problems.
|
|
|
|
|
* A weight of a cfs_rq is the sum of weights of which entities
|
|
|
|
|
* are queued on this cfs_rq, so a weight of a entity should not be
|
|
|
|
|
* too large, so as the shares value of a task group.
|
|
|
|
|
* (The default weight is 1024 - so there's no practical
|
|
|
|
|
* limitation from this.)
|
|
|
|
|
*/
|
|
|
|
|
#define MIN_SHARES (1UL << 1)
|
|
|
|
|
#define MAX_SHARES (1UL << 18)
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
typedef int (*tg_visitor)(struct task_group *, void *);
|
|
|
|
|
|
|
|
|
|
extern int walk_tg_tree_from(struct task_group *from,
|
|
|
|
|
tg_visitor down, tg_visitor up, void *data);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Iterate the full tree, calling @down when first entering a node and @up when
|
|
|
|
|
* leaving it for the final time.
|
|
|
|
|
*
|
|
|
|
|
* Caller must hold rcu_lock or sufficient equivalent.
|
|
|
|
|
*/
|
|
|
|
|
static inline int walk_tg_tree(tg_visitor down, tg_visitor up, void *data)
|
|
|
|
|
{
|
|
|
|
|
return walk_tg_tree_from(&root_task_group, down, up, data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
extern int tg_nop(struct task_group *tg, void *data);
|
|
|
|
|
|
|
|
|
|
extern void free_fair_sched_group(struct task_group *tg);
|
|
|
|
|
extern int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent);
|
|
|
|
|
extern void unregister_fair_sched_group(struct task_group *tg, int cpu);
|
|
|
|
|
extern void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
|
|
|
|
|
struct sched_entity *se, int cpu,
|
|
|
|
|
struct sched_entity *parent);
|
|
|
|
|
extern void init_cfs_bandwidth(struct cfs_bandwidth *cfs_b);
|
|
|
|
|
extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
|
|
|
|
|
|
|
|
|
|
extern void __refill_cfs_bandwidth_runtime(struct cfs_bandwidth *cfs_b);
|
2014-05-19 11:10:09 +00:00
|
|
|
extern void __start_cfs_bandwidth(struct cfs_bandwidth *cfs_b, bool force);
|
2011-10-25 08:00:11 +00:00
|
|
|
extern void unthrottle_cfs_rq(struct cfs_rq *cfs_rq);
|
|
|
|
|
|
|
|
|
|
extern void free_rt_sched_group(struct task_group *tg);
|
|
|
|
|
extern int alloc_rt_sched_group(struct task_group *tg, struct task_group *parent);
|
|
|
|
|
extern void init_tg_rt_entry(struct task_group *tg, struct rt_rq *rt_rq,
|
|
|
|
|
struct sched_rt_entity *rt_se, int cpu,
|
|
|
|
|
struct sched_rt_entity *parent);
|
|
|
|
|
|
2013-03-05 08:07:33 +00:00
|
|
|
extern struct task_group *sched_create_group(struct task_group *parent);
|
|
|
|
|
extern void sched_online_group(struct task_group *tg,
|
|
|
|
|
struct task_group *parent);
|
|
|
|
|
extern void sched_destroy_group(struct task_group *tg);
|
|
|
|
|
extern void sched_offline_group(struct task_group *tg);
|
|
|
|
|
|
|
|
|
|
extern void sched_move_task(struct task_struct *tsk);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
|
|
|
|
|
#endif
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#else /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
|
|
|
|
|
struct cfs_bandwidth { };
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
|
|
|
|
|
/* CFS-related fields in a runqueue */
|
|
|
|
|
struct cfs_rq {
|
|
|
|
|
struct load_weight load;
|
2012-04-26 11:12:27 +00:00
|
|
|
unsigned int nr_running, h_nr_running;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
u64 exec_clock;
|
|
|
|
|
u64 min_vruntime;
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
|
u64 min_vruntime_copy;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
struct rb_root tasks_timeline;
|
|
|
|
|
struct rb_node *rb_leftmost;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 'curr' points to currently running entity on this cfs_rq.
|
|
|
|
|
* It is set to NULL otherwise (i.e when none are currently running).
|
|
|
|
|
*/
|
|
|
|
|
struct sched_entity *curr, *next, *last, *skip;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
|
unsigned int nr_spread_over;
|
|
|
|
|
#endif
|
|
|
|
|
|
2012-10-04 11:18:30 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* CFS Load tracking
|
|
|
|
|
* Under CFS, load is tracked on a per-entity basis and aggregated up.
|
|
|
|
|
* This allows for the description of both thread and group usage (in
|
|
|
|
|
* the FAIR_GROUP_SCHED case).
|
|
|
|
|
*/
|
2013-06-20 02:18:53 +00:00
|
|
|
unsigned long runnable_load_avg, blocked_load_avg;
|
2013-06-20 02:18:55 +00:00
|
|
|
atomic64_t decay_counter;
|
2012-10-04 11:18:30 +00:00
|
|
|
u64 last_decay;
|
2013-06-20 02:18:55 +00:00
|
|
|
atomic_long_t removed_load;
|
2013-06-26 05:05:39 +00:00
|
|
|
|
2012-10-04 11:18:30 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
2013-06-26 05:05:39 +00:00
|
|
|
/* Required to track per-cpu representation of a task_group */
|
2012-10-04 11:18:31 +00:00
|
|
|
u32 tg_runnable_contrib;
|
2013-06-20 02:18:54 +00:00
|
|
|
unsigned long tg_load_contrib;
|
2012-10-04 11:18:31 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* h_load = weight * f(tg)
|
|
|
|
|
*
|
|
|
|
|
* Where f(tg) is the recursive weight fraction assigned to
|
|
|
|
|
* this group.
|
|
|
|
|
*/
|
|
|
|
|
unsigned long h_load;
|
sched: Move h_load calculation to task_h_load()
The bad thing about update_h_load(), which computes hierarchical load
factor for task groups, is that it is called for each task group in the
system before every load balancer run, and since rebalance can be
triggered very often, this function can eat really a lot of cpu time if
there are many cpu cgroups in the system.
Although the situation was improved significantly by commit a35b646
('sched, cgroup: Reduce rq->lock hold times for large cgroup
hierarchies'), the problem still can arise under some kinds of loads,
e.g. when cpus are switching from idle to busy and back very frequently.
For instance, when I start 1000 of processes that wake up every
millisecond on my 8 cpus host, 'top' and 'perf top' show:
Cpu(s): 17.8%us, 24.3%sy, 0.0%ni, 57.9%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 243K cycles
7.57% [kernel] [k] __schedule
7.08% [kernel] [k] timerqueue_add
6.13% libc-2.12.so [.] usleep
Then if I create 10000 *idle* cpu cgroups (no processes in them), cpu
usage increases significantly although the 'wakers' are still executing
in the root cpu cgroup:
Cpu(s): 19.1%us, 48.7%sy, 0.0%ni, 31.6%id, 0.0%wa, 0.0%hi, 0.7%si
Events: 230K cycles
24.56% [kernel] [k] tg_load_down
5.76% [kernel] [k] __schedule
This happens because this particular kind of load triggers 'new idle'
rebalance very frequently, which requires calling update_h_load(),
which, in turn, calls tg_load_down() for every *idle* cpu cgroup even
though it is absolutely useless, because idle cpu cgroups have no tasks
to pull.
This patch tries to improve the situation by making h_load calculation
proceed only when h_load is really necessary. To achieve this, it
substitutes update_h_load() with update_cfs_rq_h_load(), which computes
h_load only for a given cfs_rq and all its ascendants, and makes the
load balancer call this function whenever it considers if a task should
be pulled, i.e. it moves h_load calculations directly to task_h_load().
For h_load of the same cfs_rq not to be updated multiple times (in case
several tasks in the same cgroup are considered during the same balance
run), the patch keeps the time of the last h_load update for each cfs_rq
and breaks calculation when it finds h_load to be uptodate.
The benefit of it is that h_load is computed only for those cfs_rq's,
which really need it, in particular all idle task groups are skipped.
Although this, in fact, moves h_load calculation under rq lock, it
should not affect latency much, because the amount of work done under rq
lock while trying to pull tasks is limited by sched_nr_migrate.
After the patch applied with the setup described above (1000 wakers in
the root cgroup and 10000 idle cgroups), I get:
Cpu(s): 16.9%us, 24.8%sy, 0.0%ni, 58.4%id, 0.0%wa, 0.0%hi, 0.0%si
Events: 242K cycles
7.57% [kernel] [k] __schedule
6.70% [kernel] [k] timerqueue_add
5.93% libc-2.12.so [.] usleep
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/1373896159-1278-1-git-send-email-vdavydov@parallels.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-07-15 13:49:19 +00:00
|
|
|
u64 last_h_load_update;
|
|
|
|
|
struct sched_entity *h_load_next;
|
|
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
2012-10-04 11:18:31 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
struct rq *rq; /* cpu runqueue to which this cfs_rq is attached */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* leaf cfs_rqs are those that hold tasks (lowest schedulable entity in
|
|
|
|
|
* a hierarchy). Non-leaf lrqs hold other higher schedulable entities
|
|
|
|
|
* (like users, containers etc.)
|
|
|
|
|
*
|
|
|
|
|
* leaf_cfs_rq_list ties together list of leaf cfs_rq's in a cpu. This
|
|
|
|
|
* list is used during load balance.
|
|
|
|
|
*/
|
|
|
|
|
int on_list;
|
|
|
|
|
struct list_head leaf_cfs_rq_list;
|
|
|
|
|
struct task_group *tg; /* group that "owns" this runqueue */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CFS_BANDWIDTH
|
|
|
|
|
int runtime_enabled;
|
|
|
|
|
u64 runtime_expires;
|
|
|
|
|
s64 runtime_remaining;
|
|
|
|
|
|
2012-10-04 11:18:31 +00:00
|
|
|
u64 throttled_clock, throttled_clock_task;
|
|
|
|
|
u64 throttled_clock_task_time;
|
2011-10-25 08:00:11 +00:00
|
|
|
int throttled, throttle_count;
|
|
|
|
|
struct list_head throttled_list;
|
|
|
|
|
#endif /* CONFIG_CFS_BANDWIDTH */
|
|
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline int rt_bandwidth_enabled(void)
|
|
|
|
|
{
|
|
|
|
|
return sysctl_sched_rt_runtime >= 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Real-Time classes' related field in a runqueue: */
|
|
|
|
|
struct rt_rq {
|
|
|
|
|
struct rt_prio_array active;
|
2012-04-26 11:12:27 +00:00
|
|
|
unsigned int rt_nr_running;
|
2011-10-25 08:00:11 +00:00
|
|
|
#if defined CONFIG_SMP || defined CONFIG_RT_GROUP_SCHED
|
|
|
|
|
struct {
|
|
|
|
|
int curr; /* highest queued rt task prio */
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
int next; /* next highest */
|
|
|
|
|
#endif
|
|
|
|
|
} highest_prio;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
unsigned long rt_nr_migratory;
|
|
|
|
|
unsigned long rt_nr_total;
|
|
|
|
|
int overloaded;
|
|
|
|
|
struct plist_head pushable_tasks;
|
|
|
|
|
#endif
|
2014-03-14 22:15:00 +00:00
|
|
|
int rt_queued;
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
int rt_throttled;
|
|
|
|
|
u64 rt_time;
|
|
|
|
|
u64 rt_runtime;
|
|
|
|
|
/* Nests inside the rq lock: */
|
|
|
|
|
raw_spinlock_t rt_runtime_lock;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
|
unsigned long rt_nr_boosted;
|
|
|
|
|
|
|
|
|
|
struct rq *rq;
|
|
|
|
|
struct task_group *tg;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
/* Deadline class' related fields in a runqueue */
|
|
|
|
|
struct dl_rq {
|
|
|
|
|
/* runqueue is an rbtree, ordered by deadline */
|
|
|
|
|
struct rb_root rb_root;
|
|
|
|
|
struct rb_node *rb_leftmost;
|
|
|
|
|
|
|
|
|
|
unsigned long dl_nr_running;
|
sched/deadline: Add SCHED_DEADLINE SMP-related data structures & logic
Introduces data structures relevant for implementing dynamic
migration of -deadline tasks and the logic for checking if
runqueues are overloaded with -deadline tasks and for choosing
where a task should migrate, when it is the case.
Adds also dynamic migrations to SCHED_DEADLINE, so that tasks can
be moved among CPUs when necessary. It is also possible to bind a
task to a (set of) CPU(s), thus restricting its capability of
migrating, or forbidding migrations at all.
The very same approach used in sched_rt is utilised:
- -deadline tasks are kept into CPU-specific runqueues,
- -deadline tasks are migrated among runqueues to achieve the
following:
* on an M-CPU system the M earliest deadline ready tasks
are always running;
* affinity/cpusets settings of all the -deadline tasks is
always respected.
Therefore, this very special form of "load balancing" is done with
an active method, i.e., the scheduler pushes or pulls tasks between
runqueues when they are woken up and/or (de)scheduled.
IOW, every time a preemption occurs, the descheduled task might be sent
to some other CPU (depending on its deadline) to continue executing
(push). On the other hand, every time a CPU becomes idle, it might pull
the second earliest deadline ready task from some other CPU.
To enforce this, a pull operation is always attempted before taking any
scheduling decision (pre_schedule()), as well as a push one after each
scheduling decision (post_schedule()). In addition, when a task arrives
or wakes up, the best CPU where to resume it is selected taking into
account its affinity mask, the system topology, but also its deadline.
E.g., from the scheduling point of view, the best CPU where to wake
up (and also where to push) a task is the one which is running the task
with the latest deadline among the M executing ones.
In order to facilitate these decisions, per-runqueue "caching" of the
deadlines of the currently running and of the first ready task is used.
Queued but not running tasks are also parked in another rb-tree to
speed-up pushes.
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-5-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:38 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* Deadline values of the currently executing and the
|
|
|
|
|
* earliest ready task on this rq. Caching these facilitates
|
|
|
|
|
* the decision wether or not a ready but not running task
|
|
|
|
|
* should migrate somewhere else.
|
|
|
|
|
*/
|
|
|
|
|
struct {
|
|
|
|
|
u64 curr;
|
|
|
|
|
u64 next;
|
|
|
|
|
} earliest_dl;
|
|
|
|
|
|
|
|
|
|
unsigned long dl_nr_migratory;
|
|
|
|
|
int overloaded;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tasks on this rq that can be pushed away. They are kept in
|
|
|
|
|
* an rb-tree, ordered by tasks' deadlines, with caching
|
|
|
|
|
* of the leftmost (earliest deadline) element.
|
|
|
|
|
*/
|
|
|
|
|
struct rb_root pushable_dl_tasks_root;
|
|
|
|
|
struct rb_node *pushable_dl_tasks_leftmost;
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
#else
|
|
|
|
|
struct dl_bw dl_bw;
|
sched/deadline: Add SCHED_DEADLINE SMP-related data structures & logic
Introduces data structures relevant for implementing dynamic
migration of -deadline tasks and the logic for checking if
runqueues are overloaded with -deadline tasks and for choosing
where a task should migrate, when it is the case.
Adds also dynamic migrations to SCHED_DEADLINE, so that tasks can
be moved among CPUs when necessary. It is also possible to bind a
task to a (set of) CPU(s), thus restricting its capability of
migrating, or forbidding migrations at all.
The very same approach used in sched_rt is utilised:
- -deadline tasks are kept into CPU-specific runqueues,
- -deadline tasks are migrated among runqueues to achieve the
following:
* on an M-CPU system the M earliest deadline ready tasks
are always running;
* affinity/cpusets settings of all the -deadline tasks is
always respected.
Therefore, this very special form of "load balancing" is done with
an active method, i.e., the scheduler pushes or pulls tasks between
runqueues when they are woken up and/or (de)scheduled.
IOW, every time a preemption occurs, the descheduled task might be sent
to some other CPU (depending on its deadline) to continue executing
(push). On the other hand, every time a CPU becomes idle, it might pull
the second earliest deadline ready task from some other CPU.
To enforce this, a pull operation is always attempted before taking any
scheduling decision (pre_schedule()), as well as a push one after each
scheduling decision (post_schedule()). In addition, when a task arrives
or wakes up, the best CPU where to resume it is selected taking into
account its affinity mask, the system topology, but also its deadline.
E.g., from the scheduling point of view, the best CPU where to wake
up (and also where to push) a task is the one which is running the task
with the latest deadline among the M executing ones.
In order to facilitate these decisions, per-runqueue "caching" of the
deadlines of the currently running and of the first ready task is used.
Queued but not running tasks are also parked in another rb-tree to
speed-up pushes.
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-5-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:38 +00:00
|
|
|
#endif
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
};
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We add the notion of a root-domain which will be used to define per-domain
|
|
|
|
|
* variables. Each exclusive cpuset essentially defines an island domain by
|
|
|
|
|
* fully partitioning the member cpus from any other cpuset. Whenever a new
|
|
|
|
|
* exclusive cpuset is created, we also create and attach a new root-domain
|
|
|
|
|
* object.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
struct root_domain {
|
|
|
|
|
atomic_t refcount;
|
|
|
|
|
atomic_t rto_count;
|
|
|
|
|
struct rcu_head rcu;
|
|
|
|
|
cpumask_var_t span;
|
|
|
|
|
cpumask_var_t online;
|
|
|
|
|
|
2014-06-23 19:16:49 +00:00
|
|
|
/* Indicate more than one runnable task for any CPU */
|
|
|
|
|
bool overload;
|
|
|
|
|
|
sched/deadline: Add SCHED_DEADLINE SMP-related data structures & logic
Introduces data structures relevant for implementing dynamic
migration of -deadline tasks and the logic for checking if
runqueues are overloaded with -deadline tasks and for choosing
where a task should migrate, when it is the case.
Adds also dynamic migrations to SCHED_DEADLINE, so that tasks can
be moved among CPUs when necessary. It is also possible to bind a
task to a (set of) CPU(s), thus restricting its capability of
migrating, or forbidding migrations at all.
The very same approach used in sched_rt is utilised:
- -deadline tasks are kept into CPU-specific runqueues,
- -deadline tasks are migrated among runqueues to achieve the
following:
* on an M-CPU system the M earliest deadline ready tasks
are always running;
* affinity/cpusets settings of all the -deadline tasks is
always respected.
Therefore, this very special form of "load balancing" is done with
an active method, i.e., the scheduler pushes or pulls tasks between
runqueues when they are woken up and/or (de)scheduled.
IOW, every time a preemption occurs, the descheduled task might be sent
to some other CPU (depending on its deadline) to continue executing
(push). On the other hand, every time a CPU becomes idle, it might pull
the second earliest deadline ready task from some other CPU.
To enforce this, a pull operation is always attempted before taking any
scheduling decision (pre_schedule()), as well as a push one after each
scheduling decision (post_schedule()). In addition, when a task arrives
or wakes up, the best CPU where to resume it is selected taking into
account its affinity mask, the system topology, but also its deadline.
E.g., from the scheduling point of view, the best CPU where to wake
up (and also where to push) a task is the one which is running the task
with the latest deadline among the M executing ones.
In order to facilitate these decisions, per-runqueue "caching" of the
deadlines of the currently running and of the first ready task is used.
Queued but not running tasks are also parked in another rb-tree to
speed-up pushes.
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-5-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:38 +00:00
|
|
|
/*
|
|
|
|
|
* The bit corresponding to a CPU gets set here if such CPU has more
|
|
|
|
|
* than one runnable -deadline task (as it is below for RT tasks).
|
|
|
|
|
*/
|
|
|
|
|
cpumask_var_t dlo_mask;
|
|
|
|
|
atomic_t dlo_count;
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
struct dl_bw dl_bw;
|
2013-11-07 13:43:47 +00:00
|
|
|
struct cpudl cpudl;
|
sched/deadline: Add SCHED_DEADLINE SMP-related data structures & logic
Introduces data structures relevant for implementing dynamic
migration of -deadline tasks and the logic for checking if
runqueues are overloaded with -deadline tasks and for choosing
where a task should migrate, when it is the case.
Adds also dynamic migrations to SCHED_DEADLINE, so that tasks can
be moved among CPUs when necessary. It is also possible to bind a
task to a (set of) CPU(s), thus restricting its capability of
migrating, or forbidding migrations at all.
The very same approach used in sched_rt is utilised:
- -deadline tasks are kept into CPU-specific runqueues,
- -deadline tasks are migrated among runqueues to achieve the
following:
* on an M-CPU system the M earliest deadline ready tasks
are always running;
* affinity/cpusets settings of all the -deadline tasks is
always respected.
Therefore, this very special form of "load balancing" is done with
an active method, i.e., the scheduler pushes or pulls tasks between
runqueues when they are woken up and/or (de)scheduled.
IOW, every time a preemption occurs, the descheduled task might be sent
to some other CPU (depending on its deadline) to continue executing
(push). On the other hand, every time a CPU becomes idle, it might pull
the second earliest deadline ready task from some other CPU.
To enforce this, a pull operation is always attempted before taking any
scheduling decision (pre_schedule()), as well as a push one after each
scheduling decision (post_schedule()). In addition, when a task arrives
or wakes up, the best CPU where to resume it is selected taking into
account its affinity mask, the system topology, but also its deadline.
E.g., from the scheduling point of view, the best CPU where to wake
up (and also where to push) a task is the one which is running the task
with the latest deadline among the M executing ones.
In order to facilitate these decisions, per-runqueue "caching" of the
deadlines of the currently running and of the first ready task is used.
Queued but not running tasks are also parked in another rb-tree to
speed-up pushes.
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-5-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:38 +00:00
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* The "RT overload" flag: it gets set if a CPU has more than
|
|
|
|
|
* one runnable RT task.
|
|
|
|
|
*/
|
|
|
|
|
cpumask_var_t rto_mask;
|
|
|
|
|
struct cpupri cpupri;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
extern struct root_domain def_root_domain;
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_SMP */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This is the main, per-CPU runqueue data structure.
|
|
|
|
|
*
|
|
|
|
|
* Locking rule: those places that want to lock multiple runqueues
|
|
|
|
|
* (such as the load balancing or the thread migration code), lock
|
|
|
|
|
* acquire operations must be ordered by ascending &runqueue.
|
|
|
|
|
*/
|
|
|
|
|
struct rq {
|
|
|
|
|
/* runqueue lock: */
|
|
|
|
|
raw_spinlock_t lock;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* nr_running and cpu_load should be in the same cacheline because
|
|
|
|
|
* remote CPUs use both these fields when doing load calculation.
|
|
|
|
|
*/
|
2012-04-26 11:12:27 +00:00
|
|
|
unsigned int nr_running;
|
2013-10-07 10:29:33 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
|
unsigned int nr_numa_running;
|
|
|
|
|
unsigned int nr_preferred_running;
|
|
|
|
|
#endif
|
2011-10-25 08:00:11 +00:00
|
|
|
#define CPU_LOAD_IDX_MAX 5
|
|
|
|
|
unsigned long cpu_load[CPU_LOAD_IDX_MAX];
|
|
|
|
|
unsigned long last_load_update_tick;
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2011-10-25 08:00:11 +00:00
|
|
|
u64 nohz_stamp;
|
2011-12-02 01:07:32 +00:00
|
|
|
unsigned long nohz_flags;
|
2013-05-03 01:39:05 +00:00
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_NO_HZ_FULL
|
|
|
|
|
unsigned long last_sched_tick;
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif
|
|
|
|
|
int skip_clock_update;
|
|
|
|
|
|
|
|
|
|
/* capture load from *all* tasks on this cpu: */
|
|
|
|
|
struct load_weight load;
|
|
|
|
|
unsigned long nr_load_updates;
|
|
|
|
|
u64 nr_switches;
|
|
|
|
|
|
|
|
|
|
struct cfs_rq cfs;
|
|
|
|
|
struct rt_rq rt;
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
struct dl_rq dl;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
/* list of leaf cfs_rq on this cpu: */
|
|
|
|
|
struct list_head leaf_cfs_rq_list;
|
2014-02-26 11:19:33 +00:00
|
|
|
|
|
|
|
|
struct sched_avg avg;
|
2012-08-08 19:46:40 +00:00
|
|
|
#endif /* CONFIG_FAIR_GROUP_SCHED */
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* This is part of a global counter where only the total sum
|
|
|
|
|
* over all CPUs matters. A task can increase this counter on
|
|
|
|
|
* one CPU and if it got migrated afterwards it may decrease
|
|
|
|
|
* it on another CPU. Always updated under the runqueue lock:
|
|
|
|
|
*/
|
|
|
|
|
unsigned long nr_uninterruptible;
|
|
|
|
|
|
|
|
|
|
struct task_struct *curr, *idle, *stop;
|
|
|
|
|
unsigned long next_balance;
|
|
|
|
|
struct mm_struct *prev_mm;
|
|
|
|
|
|
|
|
|
|
u64 clock;
|
|
|
|
|
u64 clock_task;
|
|
|
|
|
|
|
|
|
|
atomic_t nr_iowait;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
struct root_domain *rd;
|
|
|
|
|
struct sched_domain *sd;
|
|
|
|
|
|
2014-05-26 22:19:38 +00:00
|
|
|
unsigned long cpu_capacity;
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
unsigned char idle_balance;
|
|
|
|
|
/* For active balancing */
|
|
|
|
|
int post_schedule;
|
|
|
|
|
int active_balance;
|
|
|
|
|
int push_cpu;
|
|
|
|
|
struct cpu_stop_work active_balance_work;
|
|
|
|
|
/* cpu of this runqueue: */
|
|
|
|
|
int cpu;
|
|
|
|
|
int online;
|
|
|
|
|
|
2012-02-20 20:49:09 +00:00
|
|
|
struct list_head cfs_tasks;
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
u64 rt_avg;
|
|
|
|
|
u64 age_stamp;
|
|
|
|
|
u64 idle_stamp;
|
|
|
|
|
u64 avg_idle;
|
2013-09-13 18:26:52 +00:00
|
|
|
|
|
|
|
|
/* This is used to determine avg_idle's max value */
|
|
|
|
|
u64 max_idle_balance_cost;
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_TIME_ACCOUNTING
|
|
|
|
|
u64 prev_irq_time;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_PARAVIRT
|
|
|
|
|
u64 prev_steal_time;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_PARAVIRT_TIME_ACCOUNTING
|
|
|
|
|
u64 prev_steal_time_rq;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* calc_load related fields */
|
|
|
|
|
unsigned long calc_load_update;
|
|
|
|
|
long calc_load_active;
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
int hrtick_csd_pending;
|
|
|
|
|
struct call_single_data hrtick_csd;
|
|
|
|
|
#endif
|
|
|
|
|
struct hrtimer hrtick_timer;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHEDSTATS
|
|
|
|
|
/* latency stats */
|
|
|
|
|
struct sched_info rq_sched_info;
|
|
|
|
|
unsigned long long rq_cpu_time;
|
|
|
|
|
/* could above be rq->cfs_rq.exec_clock + rq->rt_rq.rt_runtime ? */
|
|
|
|
|
|
|
|
|
|
/* sys_sched_yield() stats */
|
|
|
|
|
unsigned int yld_count;
|
|
|
|
|
|
|
|
|
|
/* schedule() stats */
|
|
|
|
|
unsigned int sched_count;
|
|
|
|
|
unsigned int sched_goidle;
|
|
|
|
|
|
|
|
|
|
/* try_to_wake_up() stats */
|
|
|
|
|
unsigned int ttwu_count;
|
|
|
|
|
unsigned int ttwu_local;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
struct llist_head wake_list;
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline int cpu_of(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
return rq->cpu;
|
|
|
|
|
#else
|
|
|
|
|
return 0;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DECLARE_PER_CPU(struct rq, runqueues);
|
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
#define cpu_rq(cpu) (&per_cpu(runqueues, (cpu)))
|
|
|
|
|
#define this_rq() (&__get_cpu_var(runqueues))
|
|
|
|
|
#define task_rq(p) cpu_rq(task_cpu(p))
|
|
|
|
|
#define cpu_curr(cpu) (cpu_rq(cpu)->curr)
|
|
|
|
|
#define raw_rq() (&__raw_get_cpu_var(runqueues))
|
|
|
|
|
|
2013-04-11 23:51:02 +00:00
|
|
|
static inline u64 rq_clock(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
return rq->clock;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline u64 rq_clock_task(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
return rq->clock_task;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:28:57 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
2013-10-07 10:29:33 +00:00
|
|
|
extern void sched_setnuma(struct task_struct *p, int node);
|
2013-10-07 10:29:02 +00:00
|
|
|
extern int migrate_task_to(struct task_struct *p, int cpu);
|
2013-10-07 10:29:16 +00:00
|
|
|
extern int migrate_swap(struct task_struct *, struct task_struct *);
|
2013-10-07 10:28:57 +00:00
|
|
|
#endif /* CONFIG_NUMA_BALANCING */
|
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
2014-06-04 17:31:18 +00:00
|
|
|
extern void sched_ttwu_pending(void);
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#define rcu_dereference_check_sched_domain(p) \
|
|
|
|
|
rcu_dereference_check((p), \
|
|
|
|
|
lockdep_is_held(&sched_domains_mutex))
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The domain tree (rq->sd) is protected by RCU's quiescent state transition.
|
|
|
|
|
* See detach_destroy_domains: synchronize_sched for details.
|
|
|
|
|
*
|
|
|
|
|
* The domain tree of any CPU may only be accessed from within
|
|
|
|
|
* preempt-disabled sections.
|
|
|
|
|
*/
|
|
|
|
|
#define for_each_domain(cpu, __sd) \
|
2011-12-07 14:07:31 +00:00
|
|
|
for (__sd = rcu_dereference_check_sched_domain(cpu_rq(cpu)->sd); \
|
|
|
|
|
__sd; __sd = __sd->parent)
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2011-11-17 19:08:23 +00:00
|
|
|
#define for_each_lower_domain(sd) for (; sd; sd = sd->child)
|
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
/**
|
|
|
|
|
* highest_flag_domain - Return highest sched_domain containing flag.
|
|
|
|
|
* @cpu: The cpu whose highest level of sched domain is to
|
|
|
|
|
* be returned.
|
|
|
|
|
* @flag: The flag to check for the highest sched_domain
|
|
|
|
|
* for the given cpu.
|
|
|
|
|
*
|
|
|
|
|
* Returns the highest sched_domain of a cpu which contains the given flag.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct sched_domain *highest_flag_domain(int cpu, int flag)
|
|
|
|
|
{
|
|
|
|
|
struct sched_domain *sd, *hsd = NULL;
|
|
|
|
|
|
|
|
|
|
for_each_domain(cpu, sd) {
|
|
|
|
|
if (!(sd->flags & flag))
|
|
|
|
|
break;
|
|
|
|
|
hsd = sd;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return hsd;
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-07 10:29:17 +00:00
|
|
|
static inline struct sched_domain *lowest_flag_domain(int cpu, int flag)
|
|
|
|
|
{
|
|
|
|
|
struct sched_domain *sd;
|
|
|
|
|
|
|
|
|
|
for_each_domain(cpu, sd) {
|
|
|
|
|
if (sd->flags & flag)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return sd;
|
|
|
|
|
}
|
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
DECLARE_PER_CPU(struct sched_domain *, sd_llc);
|
2013-07-04 04:56:46 +00:00
|
|
|
DECLARE_PER_CPU(int, sd_llc_size);
|
2011-12-07 14:07:31 +00:00
|
|
|
DECLARE_PER_CPU(int, sd_llc_id);
|
2013-10-07 10:29:17 +00:00
|
|
|
DECLARE_PER_CPU(struct sched_domain *, sd_numa);
|
2013-10-30 03:12:52 +00:00
|
|
|
DECLARE_PER_CPU(struct sched_domain *, sd_busy);
|
|
|
|
|
DECLARE_PER_CPU(struct sched_domain *, sd_asym);
|
2011-12-07 14:07:31 +00:00
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
struct sched_group_capacity {
|
2013-03-05 08:06:23 +00:00
|
|
|
atomic_t ref;
|
|
|
|
|
/*
|
2014-05-26 22:19:37 +00:00
|
|
|
* CPU capacity of this group, SCHED_LOAD_SCALE being max capacity
|
|
|
|
|
* for a single CPU.
|
2013-03-05 08:06:23 +00:00
|
|
|
*/
|
2014-05-26 22:19:37 +00:00
|
|
|
unsigned int capacity, capacity_orig;
|
2013-03-05 08:06:23 +00:00
|
|
|
unsigned long next_update;
|
2014-05-26 22:19:37 +00:00
|
|
|
int imbalance; /* XXX unrelated to capacity but shared group state */
|
2013-03-05 08:06:23 +00:00
|
|
|
/*
|
|
|
|
|
* Number of busy cpus in this group.
|
|
|
|
|
*/
|
|
|
|
|
atomic_t nr_busy_cpus;
|
|
|
|
|
|
|
|
|
|
unsigned long cpumask[0]; /* iteration mask */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct sched_group {
|
|
|
|
|
struct sched_group *next; /* Must be a circular list */
|
|
|
|
|
atomic_t ref;
|
|
|
|
|
|
|
|
|
|
unsigned int group_weight;
|
2014-05-26 22:19:37 +00:00
|
|
|
struct sched_group_capacity *sgc;
|
2013-03-05 08:06:23 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The CPUs this group covers.
|
|
|
|
|
*
|
|
|
|
|
* NOTE: this field is variable length. (Allocated dynamically
|
|
|
|
|
* by attaching extra space to the end of the structure,
|
|
|
|
|
* depending on how many CPUs the kernel has booted up with)
|
|
|
|
|
*/
|
|
|
|
|
unsigned long cpumask[0];
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static inline struct cpumask *sched_group_cpus(struct sched_group *sg)
|
|
|
|
|
{
|
|
|
|
|
return to_cpumask(sg->cpumask);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* cpumask masking which cpus in the group are allowed to iterate up the domain
|
|
|
|
|
* tree.
|
|
|
|
|
*/
|
|
|
|
|
static inline struct cpumask *sched_group_mask(struct sched_group *sg)
|
|
|
|
|
{
|
2014-05-26 22:19:37 +00:00
|
|
|
return to_cpumask(sg->sgc->cpumask);
|
2013-03-05 08:06:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* group_first_cpu - Returns the first cpu in the cpumask of a sched_group.
|
|
|
|
|
* @group: The group whose first cpu is to be returned.
|
|
|
|
|
*/
|
|
|
|
|
static inline unsigned int group_first_cpu(struct sched_group *group)
|
|
|
|
|
{
|
|
|
|
|
return cpumask_first(sched_group_cpus(group));
|
|
|
|
|
}
|
|
|
|
|
|
2012-05-31 12:47:33 +00:00
|
|
|
extern int group_balance_cpu(struct sched_group *sg);
|
|
|
|
|
|
2014-06-04 17:31:18 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
static inline void sched_ttwu_pending(void) { }
|
|
|
|
|
|
2011-12-07 14:07:31 +00:00
|
|
|
#endif /* CONFIG_SMP */
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2011-11-15 16:14:39 +00:00
|
|
|
#include "stats.h"
|
|
|
|
|
#include "auto_group.h"
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_CGROUP_SCHED
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Return the group to which this tasks belongs.
|
|
|
|
|
*
|
2013-08-09 00:11:22 +00:00
|
|
|
* We cannot use task_css() and friends because the cgroup subsystem
|
|
|
|
|
* changes that value before the cgroup_subsys::attach() method is called,
|
|
|
|
|
* therefore we cannot pin it and might observe the wrong value.
|
2012-06-22 11:36:05 +00:00
|
|
|
*
|
|
|
|
|
* The same is true for autogroup's p->signal->autogroup->tg, the autogroup
|
|
|
|
|
* core changes this before calling sched_move_task().
|
|
|
|
|
*
|
|
|
|
|
* Instead we use a 'copy' which is updated from sched_move_task() while
|
|
|
|
|
* holding both task_struct::pi_lock and rq::lock.
|
2011-10-25 08:00:11 +00:00
|
|
|
*/
|
|
|
|
|
static inline struct task_group *task_group(struct task_struct *p)
|
|
|
|
|
{
|
2012-06-22 11:36:05 +00:00
|
|
|
return p->sched_task_group;
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Change a task's cfs_rq and parent entity if it moves across CPUs/groups */
|
|
|
|
|
static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
#if defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED)
|
|
|
|
|
struct task_group *tg = task_group(p);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
p->se.cfs_rq = tg->cfs_rq[cpu];
|
|
|
|
|
p->se.parent = tg->se[cpu];
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_RT_GROUP_SCHED
|
|
|
|
|
p->rt.rt_rq = tg->rt_rq[cpu];
|
|
|
|
|
p->rt.parent = tg->rt_se[cpu];
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
|
|
|
|
|
static inline void set_task_rq(struct task_struct *p, unsigned int cpu) { }
|
|
|
|
|
static inline struct task_group *task_group(struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_CGROUP_SCHED */
|
|
|
|
|
|
|
|
|
|
static inline void __set_task_cpu(struct task_struct *p, unsigned int cpu)
|
|
|
|
|
{
|
|
|
|
|
set_task_rq(p, cpu);
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* After ->cpu is set up to a new value, task_rq_lock(p, ...) can be
|
|
|
|
|
* successfuly executed on another CPU. We must ensure that updates of
|
|
|
|
|
* per-task data have been completed by this moment.
|
|
|
|
|
*/
|
|
|
|
|
smp_wmb();
|
|
|
|
|
task_thread_info(p)->cpu = cpu;
|
2013-10-07 10:29:16 +00:00
|
|
|
p->wake_cpu = cpu;
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Tunables that become constants when CONFIG_SCHED_DEBUG is off:
|
|
|
|
|
*/
|
|
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
2012-02-24 07:31:31 +00:00
|
|
|
# include <linux/static_key.h>
|
2011-10-25 08:00:11 +00:00
|
|
|
# define const_debug __read_mostly
|
|
|
|
|
#else
|
|
|
|
|
# define const_debug const
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
extern const_debug unsigned int sysctl_sched_features;
|
|
|
|
|
|
|
|
|
|
#define SCHED_FEAT(name, enabled) \
|
|
|
|
|
__SCHED_FEAT_##name ,
|
|
|
|
|
|
|
|
|
|
enum {
|
2011-11-15 16:14:39 +00:00
|
|
|
#include "features.h"
|
2011-07-06 12:20:14 +00:00
|
|
|
__SCHED_FEAT_NR,
|
2011-10-25 08:00:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#undef SCHED_FEAT
|
|
|
|
|
|
2011-07-06 12:20:14 +00:00
|
|
|
#if defined(CONFIG_SCHED_DEBUG) && defined(HAVE_JUMP_LABEL)
|
|
|
|
|
#define SCHED_FEAT(name, enabled) \
|
2012-02-24 07:31:31 +00:00
|
|
|
static __always_inline bool static_branch_##name(struct static_key *key) \
|
2011-07-06 12:20:14 +00:00
|
|
|
{ \
|
2014-07-02 15:52:41 +00:00
|
|
|
return static_key_##enabled(key); \
|
2011-07-06 12:20:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#include "features.h"
|
|
|
|
|
|
|
|
|
|
#undef SCHED_FEAT
|
|
|
|
|
|
2012-02-24 07:31:31 +00:00
|
|
|
extern struct static_key sched_feat_keys[__SCHED_FEAT_NR];
|
2011-07-06 12:20:14 +00:00
|
|
|
#define sched_feat(x) (static_branch_##x(&sched_feat_keys[__SCHED_FEAT_##x]))
|
|
|
|
|
#else /* !(SCHED_DEBUG && HAVE_JUMP_LABEL) */
|
2011-10-25 08:00:11 +00:00
|
|
|
#define sched_feat(x) (sysctl_sched_features & (1UL << __SCHED_FEAT_##x))
|
2011-07-06 12:20:14 +00:00
|
|
|
#endif /* SCHED_DEBUG && HAVE_JUMP_LABEL */
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2012-10-25 12:16:43 +00:00
|
|
|
#ifdef CONFIG_NUMA_BALANCING
|
|
|
|
|
#define sched_feat_numa(x) sched_feat(x)
|
2012-11-23 11:23:49 +00:00
|
|
|
#ifdef CONFIG_SCHED_DEBUG
|
|
|
|
|
#define numabalancing_enabled sched_feat_numa(NUMA)
|
|
|
|
|
#else
|
|
|
|
|
extern bool numabalancing_enabled;
|
|
|
|
|
#endif /* CONFIG_SCHED_DEBUG */
|
2012-10-25 12:16:43 +00:00
|
|
|
#else
|
|
|
|
|
#define sched_feat_numa(x) (0)
|
2012-11-23 11:23:49 +00:00
|
|
|
#define numabalancing_enabled (0)
|
|
|
|
|
#endif /* CONFIG_NUMA_BALANCING */
|
2012-10-25 12:16:43 +00:00
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
static inline u64 global_rt_period(void)
|
|
|
|
|
{
|
|
|
|
|
return (u64)sysctl_sched_rt_period * NSEC_PER_USEC;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline u64 global_rt_runtime(void)
|
|
|
|
|
{
|
|
|
|
|
if (sysctl_sched_rt_runtime < 0)
|
|
|
|
|
return RUNTIME_INF;
|
|
|
|
|
|
|
|
|
|
return (u64)sysctl_sched_rt_runtime * NSEC_PER_USEC;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int task_current(struct rq *rq, struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
return rq->curr == p;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int task_running(struct rq *rq, struct task_struct *p)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
return p->on_cpu;
|
|
|
|
|
#else
|
|
|
|
|
return task_current(rq, p);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifndef prepare_arch_switch
|
|
|
|
|
# define prepare_arch_switch(next) do { } while (0)
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef finish_arch_switch
|
|
|
|
|
# define finish_arch_switch(prev) do { } while (0)
|
|
|
|
|
#endif
|
2011-11-27 21:43:10 +00:00
|
|
|
#ifndef finish_arch_post_lock_switch
|
|
|
|
|
# define finish_arch_post_lock_switch() do { } while (0)
|
|
|
|
|
#endif
|
2011-10-25 08:00:11 +00:00
|
|
|
|
|
|
|
|
#ifndef __ARCH_WANT_UNLOCKED_CTXSW
|
|
|
|
|
static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* We can optimise this out completely for !SMP, because the
|
|
|
|
|
* SMP rebalancing from interrupt is the only thing that cares
|
|
|
|
|
* here.
|
|
|
|
|
*/
|
|
|
|
|
next->on_cpu = 1;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* After ->on_cpu is cleared, the task can be moved to a different CPU.
|
|
|
|
|
* We must ensure this doesn't happen until the switch is completely
|
|
|
|
|
* finished.
|
|
|
|
|
*/
|
|
|
|
|
smp_wmb();
|
|
|
|
|
prev->on_cpu = 0;
|
|
|
|
|
#endif
|
|
|
|
|
#ifdef CONFIG_DEBUG_SPINLOCK
|
|
|
|
|
/* this is a valid case when another task releases the spinlock */
|
|
|
|
|
rq->lock.owner = current;
|
|
|
|
|
#endif
|
|
|
|
|
/*
|
|
|
|
|
* If we are tracking spinlock dependencies then we have to
|
|
|
|
|
* fix up the runqueue lock - which gets 'carried over' from
|
|
|
|
|
* prev into current:
|
|
|
|
|
*/
|
|
|
|
|
spin_acquire(&rq->lock.dep_map, 0, 0, _THIS_IP_);
|
|
|
|
|
|
|
|
|
|
raw_spin_unlock_irq(&rq->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* __ARCH_WANT_UNLOCKED_CTXSW */
|
|
|
|
|
static inline void prepare_lock_switch(struct rq *rq, struct task_struct *next)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* We can optimise this out completely for !SMP, because the
|
|
|
|
|
* SMP rebalancing from interrupt is the only thing that cares
|
|
|
|
|
* here.
|
|
|
|
|
*/
|
|
|
|
|
next->on_cpu = 1;
|
|
|
|
|
#endif
|
|
|
|
|
raw_spin_unlock(&rq->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void finish_lock_switch(struct rq *rq, struct task_struct *prev)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
/*
|
|
|
|
|
* After ->on_cpu is cleared, the task can be moved to a different CPU.
|
|
|
|
|
* We must ensure this doesn't happen until the switch is completely
|
|
|
|
|
* finished.
|
|
|
|
|
*/
|
|
|
|
|
smp_wmb();
|
|
|
|
|
prev->on_cpu = 0;
|
|
|
|
|
#endif
|
|
|
|
|
local_irq_enable();
|
|
|
|
|
}
|
|
|
|
|
#endif /* __ARCH_WANT_UNLOCKED_CTXSW */
|
|
|
|
|
|
2013-03-05 08:06:38 +00:00
|
|
|
/*
|
|
|
|
|
* wake flags
|
|
|
|
|
*/
|
|
|
|
|
#define WF_SYNC 0x01 /* waker goes to sleep after wakeup */
|
|
|
|
|
#define WF_FORK 0x02 /* child wakeup after fork */
|
|
|
|
|
#define WF_MIGRATED 0x4 /* internal use, task got migrated */
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* To aid in avoiding the subversion of "niceness" due to uneven distribution
|
|
|
|
|
* of tasks with abnormal "nice" values across CPUs the contribution that
|
|
|
|
|
* each task makes to its run queue's load is weighted according to its
|
|
|
|
|
* scheduling class and "nice" value. For SCHED_NORMAL tasks this is just a
|
|
|
|
|
* scaled version of the new time slice allocation that they receive on time
|
|
|
|
|
* slice expiry etc.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define WEIGHT_IDLEPRIO 3
|
|
|
|
|
#define WMULT_IDLEPRIO 1431655765
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Nice levels are multiplicative, with a gentle 10% change for every
|
|
|
|
|
* nice level changed. I.e. when a CPU-bound task goes from nice 0 to
|
|
|
|
|
* nice 1, it will get ~10% less CPU time than another CPU-bound task
|
|
|
|
|
* that remained on nice 0.
|
|
|
|
|
*
|
|
|
|
|
* The "10% effect" is relative and cumulative: from _any_ nice level,
|
|
|
|
|
* if you go up 1 level, it's -10% CPU usage, if you go down 1 level
|
|
|
|
|
* it's +10% CPU usage. (to achieve that we use a multiplier of 1.25.
|
|
|
|
|
* If a task goes up by ~10% and another task goes down by ~10% then
|
|
|
|
|
* the relative distance between them is ~25%.)
|
|
|
|
|
*/
|
|
|
|
|
static const int prio_to_weight[40] = {
|
|
|
|
|
/* -20 */ 88761, 71755, 56483, 46273, 36291,
|
|
|
|
|
/* -15 */ 29154, 23254, 18705, 14949, 11916,
|
|
|
|
|
/* -10 */ 9548, 7620, 6100, 4904, 3906,
|
|
|
|
|
/* -5 */ 3121, 2501, 1991, 1586, 1277,
|
|
|
|
|
/* 0 */ 1024, 820, 655, 526, 423,
|
|
|
|
|
/* 5 */ 335, 272, 215, 172, 137,
|
|
|
|
|
/* 10 */ 110, 87, 70, 56, 45,
|
|
|
|
|
/* 15 */ 36, 29, 23, 18, 15,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Inverse (2^32/x) values of the prio_to_weight[] array, precalculated.
|
|
|
|
|
*
|
|
|
|
|
* In cases where the weight does not change often, we can use the
|
|
|
|
|
* precalculated inverse to speed up arithmetics by turning divisions
|
|
|
|
|
* into multiplications:
|
|
|
|
|
*/
|
|
|
|
|
static const u32 prio_to_wmult[40] = {
|
|
|
|
|
/* -20 */ 48388, 59856, 76040, 92818, 118348,
|
|
|
|
|
/* -15 */ 147320, 184698, 229616, 287308, 360437,
|
|
|
|
|
/* -10 */ 449829, 563644, 704093, 875809, 1099582,
|
|
|
|
|
/* -5 */ 1376151, 1717300, 2157191, 2708050, 3363326,
|
|
|
|
|
/* 0 */ 4194304, 5237765, 6557202, 8165337, 10153587,
|
|
|
|
|
/* 5 */ 12820798, 15790321, 19976592, 24970740, 31350126,
|
|
|
|
|
/* 10 */ 39045157, 49367440, 61356676, 76695844, 95443717,
|
|
|
|
|
/* 15 */ 119304647, 148102320, 186737708, 238609294, 286331153,
|
|
|
|
|
};
|
|
|
|
|
|
2013-03-05 08:06:55 +00:00
|
|
|
#define ENQUEUE_WAKEUP 1
|
|
|
|
|
#define ENQUEUE_HEAD 2
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
#define ENQUEUE_WAKING 4 /* sched_class::task_waking was called */
|
|
|
|
|
#else
|
|
|
|
|
#define ENQUEUE_WAKING 0
|
|
|
|
|
#endif
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
#define ENQUEUE_REPLENISH 8
|
2013-03-05 08:06:55 +00:00
|
|
|
|
|
|
|
|
#define DEQUEUE_SLEEP 1
|
|
|
|
|
|
2014-02-14 11:25:08 +00:00
|
|
|
#define RETRY_TASK ((void *)-1UL)
|
|
|
|
|
|
2013-03-05 08:06:55 +00:00
|
|
|
struct sched_class {
|
|
|
|
|
const struct sched_class *next;
|
|
|
|
|
|
|
|
|
|
void (*enqueue_task) (struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
void (*dequeue_task) (struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
void (*yield_task) (struct rq *rq);
|
|
|
|
|
bool (*yield_to_task) (struct rq *rq, struct task_struct *p, bool preempt);
|
|
|
|
|
|
|
|
|
|
void (*check_preempt_curr) (struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
|
2012-02-11 05:05:00 +00:00
|
|
|
/*
|
|
|
|
|
* It is the responsibility of the pick_next_task() method that will
|
|
|
|
|
* return the next task to call put_prev_task() on the @prev task or
|
|
|
|
|
* something equivalent.
|
2014-02-14 11:25:08 +00:00
|
|
|
*
|
|
|
|
|
* May return RETRY_TASK when it finds a higher prio class has runnable
|
|
|
|
|
* tasks.
|
2012-02-11 05:05:00 +00:00
|
|
|
*/
|
|
|
|
|
struct task_struct * (*pick_next_task) (struct rq *rq,
|
|
|
|
|
struct task_struct *prev);
|
2013-03-05 08:06:55 +00:00
|
|
|
void (*put_prev_task) (struct rq *rq, struct task_struct *p);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
2013-10-07 10:29:16 +00:00
|
|
|
int (*select_task_rq)(struct task_struct *p, int task_cpu, int sd_flag, int flags);
|
2013-03-05 08:06:55 +00:00
|
|
|
void (*migrate_task_rq)(struct task_struct *p, int next_cpu);
|
|
|
|
|
|
|
|
|
|
void (*post_schedule) (struct rq *this_rq);
|
|
|
|
|
void (*task_waking) (struct task_struct *task);
|
|
|
|
|
void (*task_woken) (struct rq *this_rq, struct task_struct *task);
|
|
|
|
|
|
|
|
|
|
void (*set_cpus_allowed)(struct task_struct *p,
|
|
|
|
|
const struct cpumask *newmask);
|
|
|
|
|
|
|
|
|
|
void (*rq_online)(struct rq *rq);
|
|
|
|
|
void (*rq_offline)(struct rq *rq);
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
void (*set_curr_task) (struct rq *rq);
|
|
|
|
|
void (*task_tick) (struct rq *rq, struct task_struct *p, int queued);
|
|
|
|
|
void (*task_fork) (struct task_struct *p);
|
2013-11-07 13:43:35 +00:00
|
|
|
void (*task_dead) (struct task_struct *p);
|
2013-03-05 08:06:55 +00:00
|
|
|
|
|
|
|
|
void (*switched_from) (struct rq *this_rq, struct task_struct *task);
|
|
|
|
|
void (*switched_to) (struct rq *this_rq, struct task_struct *task);
|
|
|
|
|
void (*prio_changed) (struct rq *this_rq, struct task_struct *task,
|
|
|
|
|
int oldprio);
|
|
|
|
|
|
|
|
|
|
unsigned int (*get_rr_interval) (struct rq *rq,
|
|
|
|
|
struct task_struct *task);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FAIR_GROUP_SCHED
|
|
|
|
|
void (*task_move_group) (struct task_struct *p, int on_rq);
|
|
|
|
|
#endif
|
|
|
|
|
};
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2014-02-12 09:49:30 +00:00
|
|
|
static inline void put_prev_task(struct rq *rq, struct task_struct *prev)
|
|
|
|
|
{
|
|
|
|
|
prev->sched_class->put_prev_task(rq, prev);
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#define sched_class_highest (&stop_sched_class)
|
|
|
|
|
#define for_each_class(class) \
|
|
|
|
|
for (class = sched_class_highest; class; class = class->next)
|
|
|
|
|
|
|
|
|
|
extern const struct sched_class stop_sched_class;
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
extern const struct sched_class dl_sched_class;
|
2011-10-25 08:00:11 +00:00
|
|
|
extern const struct sched_class rt_sched_class;
|
|
|
|
|
extern const struct sched_class fair_sched_class;
|
|
|
|
|
extern const struct sched_class idle_sched_class;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
|
2014-05-26 22:19:37 +00:00
|
|
|
extern void update_group_capacity(struct sched_domain *sd, int cpu);
|
2013-03-07 02:00:26 +00:00
|
|
|
|
2014-01-06 11:34:38 +00:00
|
|
|
extern void trigger_load_balance(struct rq *rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
sched: Fix wrong rq's runnable_avg update with rt tasks
The current update of the rq's load can be erroneous when RT
tasks are involved.
The update of the load of a rq that becomes idle, is done only
if the avg_idle is less than sysctl_sched_migration_cost. If RT
tasks and short idle duration alternate, the runnable_avg will
not be updated correctly and the time will be accounted as idle
time when a CFS task wakes up.
A new idle_enter function is called when the next task is the
idle function so the elapsed time will be accounted as run time
in the load of the rq, whatever the average idle time is. The
function update_rq_runnable_avg is removed from idle_balance.
When a RT task is scheduled on an idle CPU, the update of the
rq's load is not done when the rq exit idle state because CFS's
functions are not called. Then, the idle_balance, which is
called just before entering the idle function, updates the rq's
load and makes the assumption that the elapsed time since the
last update, was only running time.
As a consequence, the rq's load of a CPU that only runs a
periodic RT task, is close to LOAD_AVG_MAX whatever the running
duration of the RT task is.
A new idle_exit function is called when the prev task is the
idle function so the elapsed time will be accounted as idle time
in the rq's load.
Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Acked-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Acked-by: Steven Rostedt <rostedt@goodmis.org>
Cc: linaro-kernel@lists.linaro.org
Cc: peterz@infradead.org
Cc: pjt@google.com
Cc: fweisbec@gmail.com
Cc: efault@gmx.de
Link: http://lkml.kernel.org/r/1366302867-5055-1-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-04-18 16:34:26 +00:00
|
|
|
extern void idle_enter_fair(struct rq *this_rq);
|
|
|
|
|
extern void idle_exit_fair(struct rq *this_rq);
|
|
|
|
|
|
2014-02-12 14:47:29 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
static inline void idle_enter_fair(struct rq *rq) { }
|
|
|
|
|
static inline void idle_exit_fair(struct rq *rq) { }
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
extern void sysrq_sched_debug_show(void);
|
|
|
|
|
extern void sched_init_granularity(void);
|
|
|
|
|
extern void update_max_interval(void);
|
sched/deadline: Add SCHED_DEADLINE SMP-related data structures & logic
Introduces data structures relevant for implementing dynamic
migration of -deadline tasks and the logic for checking if
runqueues are overloaded with -deadline tasks and for choosing
where a task should migrate, when it is the case.
Adds also dynamic migrations to SCHED_DEADLINE, so that tasks can
be moved among CPUs when necessary. It is also possible to bind a
task to a (set of) CPU(s), thus restricting its capability of
migrating, or forbidding migrations at all.
The very same approach used in sched_rt is utilised:
- -deadline tasks are kept into CPU-specific runqueues,
- -deadline tasks are migrated among runqueues to achieve the
following:
* on an M-CPU system the M earliest deadline ready tasks
are always running;
* affinity/cpusets settings of all the -deadline tasks is
always respected.
Therefore, this very special form of "load balancing" is done with
an active method, i.e., the scheduler pushes or pulls tasks between
runqueues when they are woken up and/or (de)scheduled.
IOW, every time a preemption occurs, the descheduled task might be sent
to some other CPU (depending on its deadline) to continue executing
(push). On the other hand, every time a CPU becomes idle, it might pull
the second earliest deadline ready task from some other CPU.
To enforce this, a pull operation is always attempted before taking any
scheduling decision (pre_schedule()), as well as a push one after each
scheduling decision (post_schedule()). In addition, when a task arrives
or wakes up, the best CPU where to resume it is selected taking into
account its affinity mask, the system topology, but also its deadline.
E.g., from the scheduling point of view, the best CPU where to wake
up (and also where to push) a task is the one which is running the task
with the latest deadline among the M executing ones.
In order to facilitate these decisions, per-runqueue "caching" of the
deadlines of the currently running and of the first ready task is used.
Queued but not running tasks are also parked in another rb-tree to
speed-up pushes.
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-5-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:38 +00:00
|
|
|
|
|
|
|
|
extern void init_sched_dl_class(void);
|
2011-10-25 08:00:11 +00:00
|
|
|
extern void init_sched_rt_class(void);
|
|
|
|
|
extern void init_sched_fair_class(void);
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
extern void init_sched_dl_class(void);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2014-06-28 20:03:57 +00:00
|
|
|
extern void resched_curr(struct rq *rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
extern void resched_cpu(int cpu);
|
|
|
|
|
|
|
|
|
|
extern struct rt_bandwidth def_rt_bandwidth;
|
|
|
|
|
extern void init_rt_bandwidth(struct rt_bandwidth *rt_b, u64 period, u64 runtime);
|
|
|
|
|
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
extern struct dl_bandwidth def_dl_bandwidth;
|
|
|
|
|
extern void init_dl_bandwidth(struct dl_bandwidth *dl_b, u64 period, u64 runtime);
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
extern void init_dl_task_timer(struct sched_dl_entity *dl_se);
|
|
|
|
|
|
sched/deadline: Add bandwidth management for SCHED_DEADLINE tasks
In order of deadline scheduling to be effective and useful, it is
important that some method of having the allocation of the available
CPU bandwidth to tasks and task groups under control.
This is usually called "admission control" and if it is not performed
at all, no guarantee can be given on the actual scheduling of the
-deadline tasks.
Since when RT-throttling has been introduced each task group have a
bandwidth associated to itself, calculated as a certain amount of
runtime over a period. Moreover, to make it possible to manipulate
such bandwidth, readable/writable controls have been added to both
procfs (for system wide settings) and cgroupfs (for per-group
settings).
Therefore, the same interface is being used for controlling the
bandwidth distrubution to -deadline tasks and task groups, i.e.,
new controls but with similar names, equivalent meaning and with
the same usage paradigm are added.
However, more discussion is needed in order to figure out how
we want to manage SCHED_DEADLINE bandwidth at the task group level.
Therefore, this patch adds a less sophisticated, but actually
very sensible, mechanism to ensure that a certain utilization
cap is not overcome per each root_domain (the single rq for !SMP
configurations).
Another main difference between deadline bandwidth management and
RT-throttling is that -deadline tasks have bandwidth on their own
(while -rt ones doesn't!), and thus we don't need an higher level
throttling mechanism to enforce the desired bandwidth.
This patch, therefore:
- adds system wide deadline bandwidth management by means of:
* /proc/sys/kernel/sched_dl_runtime_us,
* /proc/sys/kernel/sched_dl_period_us,
that determine (i.e., runtime / period) the total bandwidth
available on each CPU of each root_domain for -deadline tasks;
- couples the RT and deadline bandwidth management, i.e., enforces
that the sum of how much bandwidth is being devoted to -rt
-deadline tasks to stay below 100%.
This means that, for a root_domain comprising M CPUs, -deadline tasks
can be created until the sum of their bandwidths stay below:
M * (sched_dl_runtime_us / sched_dl_period_us)
It is also possible to disable this bandwidth management logic, and
be thus free of oversubscribing the system up to any arbitrary level.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-12-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-07 13:43:45 +00:00
|
|
|
unsigned long to_ratio(u64 period, u64 runtime);
|
|
|
|
|
|
2012-05-11 15:31:26 +00:00
|
|
|
extern void update_idle_cpu_load(struct rq *this_rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-06-20 02:18:47 +00:00
|
|
|
extern void init_task_runnable_average(struct task_struct *p);
|
|
|
|
|
|
2014-05-08 23:00:14 +00:00
|
|
|
static inline void add_nr_running(struct rq *rq, unsigned count)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2014-05-08 23:00:14 +00:00
|
|
|
unsigned prev_nr = rq->nr_running;
|
|
|
|
|
|
|
|
|
|
rq->nr_running = prev_nr + count;
|
2013-04-20 12:35:09 +00:00
|
|
|
|
2014-05-08 23:00:14 +00:00
|
|
|
if (prev_nr < 2 && rq->nr_running >= 2) {
|
2014-06-23 19:16:49 +00:00
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
if (!rq->rd->overload)
|
|
|
|
|
rq->rd->overload = true;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_NO_HZ_FULL
|
2013-04-20 12:35:09 +00:00
|
|
|
if (tick_nohz_full_cpu(rq->cpu)) {
|
2014-03-18 21:54:04 +00:00
|
|
|
/*
|
|
|
|
|
* Tick is needed if more than one task runs on a CPU.
|
|
|
|
|
* Send the target an IPI to kick it out of nohz mode.
|
|
|
|
|
*
|
|
|
|
|
* We assume that IPI implies full memory barrier and the
|
|
|
|
|
* new value of rq->nr_running is visible on reception
|
|
|
|
|
* from the target.
|
|
|
|
|
*/
|
2014-03-18 20:12:53 +00:00
|
|
|
tick_nohz_full_kick_cpu(rq->cpu);
|
2013-04-20 12:35:09 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2014-06-23 19:16:49 +00:00
|
|
|
}
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
2014-05-08 23:00:14 +00:00
|
|
|
static inline void sub_nr_running(struct rq *rq, unsigned count)
|
2011-10-25 08:00:11 +00:00
|
|
|
{
|
2014-05-08 23:00:14 +00:00
|
|
|
rq->nr_running -= count;
|
2011-10-25 08:00:11 +00:00
|
|
|
}
|
|
|
|
|
|
2013-05-03 01:39:05 +00:00
|
|
|
static inline void rq_last_tick_reset(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_NO_HZ_FULL
|
|
|
|
|
rq->last_sched_tick = jiffies;
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
extern void update_rq_clock(struct rq *rq);
|
|
|
|
|
|
|
|
|
|
extern void activate_task(struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
extern void deactivate_task(struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
|
|
|
|
|
extern void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags);
|
|
|
|
|
|
|
|
|
|
extern const_debug unsigned int sysctl_sched_time_avg;
|
|
|
|
|
extern const_debug unsigned int sysctl_sched_nr_migrate;
|
|
|
|
|
extern const_debug unsigned int sysctl_sched_migration_cost;
|
|
|
|
|
|
|
|
|
|
static inline u64 sched_avg_period(void)
|
|
|
|
|
{
|
|
|
|
|
return (u64)sysctl_sched_time_avg * NSEC_PER_MSEC / 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SCHED_HRTICK
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Use hrtick when:
|
|
|
|
|
* - enabled by features
|
|
|
|
|
* - hrtimer is actually high res
|
|
|
|
|
*/
|
|
|
|
|
static inline int hrtick_enabled(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
if (!sched_feat(HRTICK))
|
|
|
|
|
return 0;
|
|
|
|
|
if (!cpu_active(cpu_of(rq)))
|
|
|
|
|
return 0;
|
|
|
|
|
return hrtimer_is_hres_active(&rq->hrtick_timer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void hrtick_start(struct rq *rq, u64 delay);
|
|
|
|
|
|
2011-11-22 14:20:07 +00:00
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
static inline int hrtick_enabled(struct rq *rq)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
#endif /* CONFIG_SCHED_HRTICK */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
extern void sched_avg_update(struct rq *rq);
|
|
|
|
|
static inline void sched_rt_avg_update(struct rq *rq, u64 rt_delta)
|
|
|
|
|
{
|
|
|
|
|
rq->rt_avg += rt_delta;
|
|
|
|
|
sched_avg_update(rq);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
static inline void sched_rt_avg_update(struct rq *rq, u64 rt_delta) { }
|
|
|
|
|
static inline void sched_avg_update(struct rq *rq) { }
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
extern void start_bandwidth_timer(struct hrtimer *period_timer, ktime_t period);
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
|
#ifdef CONFIG_PREEMPT
|
|
|
|
|
|
|
|
|
|
static inline void double_rq_lock(struct rq *rq1, struct rq *rq2);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* fair double_lock_balance: Safely acquires both rq->locks in a fair
|
|
|
|
|
* way at the expense of forcing extra atomic operations in all
|
|
|
|
|
* invocations. This assures that the double_lock is acquired using the
|
|
|
|
|
* same underlying policy as the spinlock_t on this architecture, which
|
|
|
|
|
* reduces latency compared to the unfair variant below. However, it
|
|
|
|
|
* also adds more overhead and therefore may reduce throughput.
|
|
|
|
|
*/
|
|
|
|
|
static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
|
__releases(this_rq->lock)
|
|
|
|
|
__acquires(busiest->lock)
|
|
|
|
|
__acquires(this_rq->lock)
|
|
|
|
|
{
|
|
|
|
|
raw_spin_unlock(&this_rq->lock);
|
|
|
|
|
double_rq_lock(this_rq, busiest);
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
/*
|
|
|
|
|
* Unfair double_lock_balance: Optimizes throughput at the expense of
|
|
|
|
|
* latency by eliminating extra atomic operations when the locks are
|
|
|
|
|
* already in proper order on entry. This favors lower cpu-ids and will
|
|
|
|
|
* grant the double lock to lower cpus over higher ids under contention,
|
|
|
|
|
* regardless of entry order into the function.
|
|
|
|
|
*/
|
|
|
|
|
static inline int _double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
|
__releases(this_rq->lock)
|
|
|
|
|
__acquires(busiest->lock)
|
|
|
|
|
__acquires(this_rq->lock)
|
|
|
|
|
{
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
if (unlikely(!raw_spin_trylock(&busiest->lock))) {
|
|
|
|
|
if (busiest < this_rq) {
|
|
|
|
|
raw_spin_unlock(&this_rq->lock);
|
|
|
|
|
raw_spin_lock(&busiest->lock);
|
|
|
|
|
raw_spin_lock_nested(&this_rq->lock,
|
|
|
|
|
SINGLE_DEPTH_NESTING);
|
|
|
|
|
ret = 1;
|
|
|
|
|
} else
|
|
|
|
|
raw_spin_lock_nested(&busiest->lock,
|
|
|
|
|
SINGLE_DEPTH_NESTING);
|
|
|
|
|
}
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif /* CONFIG_PREEMPT */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* double_lock_balance - lock the busiest runqueue, this_rq is locked already.
|
|
|
|
|
*/
|
|
|
|
|
static inline int double_lock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
|
{
|
|
|
|
|
if (unlikely(!irqs_disabled())) {
|
|
|
|
|
/* printk() doesn't work good under rq->lock */
|
|
|
|
|
raw_spin_unlock(&this_rq->lock);
|
|
|
|
|
BUG_ON(1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return _double_lock_balance(this_rq, busiest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void double_unlock_balance(struct rq *this_rq, struct rq *busiest)
|
|
|
|
|
__releases(busiest->lock)
|
|
|
|
|
{
|
|
|
|
|
raw_spin_unlock(&busiest->lock);
|
|
|
|
|
lock_set_subclass(&this_rq->lock.dep_map, 0, _RET_IP_);
|
|
|
|
|
}
|
|
|
|
|
|
sched: Fix race in migrate_swap_stop()
There is a subtle race in migrate_swap, when task P, on CPU A, decides to swap
places with task T, on CPU B.
Task P:
- call migrate_swap
Task T:
- go to sleep, removing itself from the runqueue
Task P:
- double lock the runqueues on CPU A & B
Task T:
- get woken up, place itself on the runqueue of CPU C
Task P:
- see that task T is on a runqueue, and pretend to remove it
from the runqueue on CPU B
Now CPUs B & C both have corrupted scheduler data structures.
This patch fixes it, by holding the pi_lock for both of the tasks
involved in the migrate swap. This prevents task T from waking up,
and placing itself onto another runqueue, until after migrate_swap
has released all locks.
This means that, when migrate_swap checks, task T will be either
on the runqueue where it was originally seen, or not on any
runqueue at all. Migrate_swap deals correctly with of those cases.
Tested-by: Joe Mario <jmario@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: hannes@cmpxchg.org
Cc: aarcange@redhat.com
Cc: srikar@linux.vnet.ibm.com
Cc: tglx@linutronix.de
Cc: hpa@zytor.com
Link: http://lkml.kernel.org/r/20131010181722.GO13848@laptop.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-10-10 18:17:22 +00:00
|
|
|
static inline void double_lock(spinlock_t *l1, spinlock_t *l2)
|
|
|
|
|
{
|
|
|
|
|
if (l1 > l2)
|
|
|
|
|
swap(l1, l2);
|
|
|
|
|
|
|
|
|
|
spin_lock(l1);
|
|
|
|
|
spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-07 08:55:15 +00:00
|
|
|
static inline void double_lock_irq(spinlock_t *l1, spinlock_t *l2)
|
|
|
|
|
{
|
|
|
|
|
if (l1 > l2)
|
|
|
|
|
swap(l1, l2);
|
|
|
|
|
|
|
|
|
|
spin_lock_irq(l1);
|
|
|
|
|
spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
|
|
|
|
|
}
|
|
|
|
|
|
sched: Fix race in migrate_swap_stop()
There is a subtle race in migrate_swap, when task P, on CPU A, decides to swap
places with task T, on CPU B.
Task P:
- call migrate_swap
Task T:
- go to sleep, removing itself from the runqueue
Task P:
- double lock the runqueues on CPU A & B
Task T:
- get woken up, place itself on the runqueue of CPU C
Task P:
- see that task T is on a runqueue, and pretend to remove it
from the runqueue on CPU B
Now CPUs B & C both have corrupted scheduler data structures.
This patch fixes it, by holding the pi_lock for both of the tasks
involved in the migrate swap. This prevents task T from waking up,
and placing itself onto another runqueue, until after migrate_swap
has released all locks.
This means that, when migrate_swap checks, task T will be either
on the runqueue where it was originally seen, or not on any
runqueue at all. Migrate_swap deals correctly with of those cases.
Tested-by: Joe Mario <jmario@redhat.com>
Acked-by: Mel Gorman <mgorman@suse.de>
Reviewed-by: Rik van Riel <riel@redhat.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: hannes@cmpxchg.org
Cc: aarcange@redhat.com
Cc: srikar@linux.vnet.ibm.com
Cc: tglx@linutronix.de
Cc: hpa@zytor.com
Link: http://lkml.kernel.org/r/20131010181722.GO13848@laptop.programming.kicks-ass.net
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-10-10 18:17:22 +00:00
|
|
|
static inline void double_raw_lock(raw_spinlock_t *l1, raw_spinlock_t *l2)
|
|
|
|
|
{
|
|
|
|
|
if (l1 > l2)
|
|
|
|
|
swap(l1, l2);
|
|
|
|
|
|
|
|
|
|
raw_spin_lock(l1);
|
|
|
|
|
raw_spin_lock_nested(l2, SINGLE_DEPTH_NESTING);
|
|
|
|
|
}
|
|
|
|
|
|
2011-10-25 08:00:11 +00:00
|
|
|
/*
|
|
|
|
|
* double_rq_lock - safely lock two runqueues
|
|
|
|
|
*
|
|
|
|
|
* Note this does not disable interrupts like task_rq_lock,
|
|
|
|
|
* you need to do so manually before calling.
|
|
|
|
|
*/
|
|
|
|
|
static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
|
|
|
|
|
__acquires(rq1->lock)
|
|
|
|
|
__acquires(rq2->lock)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(!irqs_disabled());
|
|
|
|
|
if (rq1 == rq2) {
|
|
|
|
|
raw_spin_lock(&rq1->lock);
|
|
|
|
|
__acquire(rq2->lock); /* Fake it out ;) */
|
|
|
|
|
} else {
|
|
|
|
|
if (rq1 < rq2) {
|
|
|
|
|
raw_spin_lock(&rq1->lock);
|
|
|
|
|
raw_spin_lock_nested(&rq2->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
|
} else {
|
|
|
|
|
raw_spin_lock(&rq2->lock);
|
|
|
|
|
raw_spin_lock_nested(&rq1->lock, SINGLE_DEPTH_NESTING);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* double_rq_unlock - safely unlock two runqueues
|
|
|
|
|
*
|
|
|
|
|
* Note this does not restore interrupts like task_rq_unlock,
|
|
|
|
|
* you need to do so manually after calling.
|
|
|
|
|
*/
|
|
|
|
|
static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
|
|
|
|
|
__releases(rq1->lock)
|
|
|
|
|
__releases(rq2->lock)
|
|
|
|
|
{
|
|
|
|
|
raw_spin_unlock(&rq1->lock);
|
|
|
|
|
if (rq1 != rq2)
|
|
|
|
|
raw_spin_unlock(&rq2->lock);
|
|
|
|
|
else
|
|
|
|
|
__release(rq2->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#else /* CONFIG_SMP */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* double_rq_lock - safely lock two runqueues
|
|
|
|
|
*
|
|
|
|
|
* Note this does not disable interrupts like task_rq_lock,
|
|
|
|
|
* you need to do so manually before calling.
|
|
|
|
|
*/
|
|
|
|
|
static inline void double_rq_lock(struct rq *rq1, struct rq *rq2)
|
|
|
|
|
__acquires(rq1->lock)
|
|
|
|
|
__acquires(rq2->lock)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(!irqs_disabled());
|
|
|
|
|
BUG_ON(rq1 != rq2);
|
|
|
|
|
raw_spin_lock(&rq1->lock);
|
|
|
|
|
__acquire(rq2->lock); /* Fake it out ;) */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* double_rq_unlock - safely unlock two runqueues
|
|
|
|
|
*
|
|
|
|
|
* Note this does not restore interrupts like task_rq_unlock,
|
|
|
|
|
* you need to do so manually after calling.
|
|
|
|
|
*/
|
|
|
|
|
static inline void double_rq_unlock(struct rq *rq1, struct rq *rq2)
|
|
|
|
|
__releases(rq1->lock)
|
|
|
|
|
__releases(rq2->lock)
|
|
|
|
|
{
|
|
|
|
|
BUG_ON(rq1 != rq2);
|
|
|
|
|
raw_spin_unlock(&rq1->lock);
|
|
|
|
|
__release(rq2->lock);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
extern struct sched_entity *__pick_first_entity(struct cfs_rq *cfs_rq);
|
|
|
|
|
extern struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq);
|
|
|
|
|
extern void print_cfs_stats(struct seq_file *m, int cpu);
|
|
|
|
|
extern void print_rt_stats(struct seq_file *m, int cpu);
|
|
|
|
|
|
|
|
|
|
extern void init_cfs_rq(struct cfs_rq *cfs_rq);
|
|
|
|
|
extern void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq);
|
sched/deadline: Add SCHED_DEADLINE structures & implementation
Introduces the data structures, constants and symbols needed for
SCHED_DEADLINE implementation.
Core data structure of SCHED_DEADLINE are defined, along with their
initializers. Hooks for checking if a task belong to the new policy
are also added where they are needed.
Adds a scheduling class, in sched/dl.c and a new policy called
SCHED_DEADLINE. It is an implementation of the Earliest Deadline
First (EDF) scheduling algorithm, augmented with a mechanism (called
Constant Bandwidth Server, CBS) that makes it possible to isolate
the behaviour of tasks between each other.
The typical -deadline task will be made up of a computation phase
(instance) which is activated on a periodic or sporadic fashion. The
expected (maximum) duration of such computation is called the task's
runtime; the time interval by which each instance need to be completed
is called the task's relative deadline. The task's absolute deadline
is dynamically calculated as the time instant a task (better, an
instance) activates plus the relative deadline.
The EDF algorithms selects the task with the smallest absolute
deadline as the one to be executed first, while the CBS ensures each
task to run for at most its runtime every (relative) deadline
length time interval, avoiding any interference between different
tasks (bandwidth isolation).
Thanks to this feature, also tasks that do not strictly comply with
the computational model sketched above can effectively use the new
policy.
To summarize, this patch:
- introduces the data structures, constants and symbols needed;
- implements the core logic of the scheduling algorithm in the new
scheduling class file;
- provides all the glue code between the new scheduling class and
the core scheduler and refines the interactions between sched/dl
and the other existing scheduling classes.
Signed-off-by: Dario Faggioli <raistlin@linux.it>
Signed-off-by: Michael Trimarchi <michael@amarulasolutions.com>
Signed-off-by: Fabio Checconi <fchecconi@gmail.com>
Signed-off-by: Juri Lelli <juri.lelli@gmail.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1383831828-15501-4-git-send-email-juri.lelli@gmail.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2013-11-28 10:14:43 +00:00
|
|
|
extern void init_dl_rq(struct dl_rq *dl_rq, struct rq *rq);
|
2011-10-25 08:00:11 +00:00
|
|
|
|
2013-10-16 18:16:12 +00:00
|
|
|
extern void cfs_bandwidth_usage_inc(void);
|
|
|
|
|
extern void cfs_bandwidth_usage_dec(void);
|
2011-12-02 01:07:32 +00:00
|
|
|
|
2011-08-10 21:21:01 +00:00
|
|
|
#ifdef CONFIG_NO_HZ_COMMON
|
2011-12-02 01:07:32 +00:00
|
|
|
enum rq_nohz_flag_bits {
|
|
|
|
|
NOHZ_TICK_STOPPED,
|
|
|
|
|
NOHZ_BALANCE_KICK,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#define nohz_flags(cpu) (&cpu_rq(cpu)->nohz_flags)
|
|
|
|
|
#endif
|
2012-06-16 13:57:37 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_IRQ_TIME_ACCOUNTING
|
|
|
|
|
|
|
|
|
|
DECLARE_PER_CPU(u64, cpu_hardirq_time);
|
|
|
|
|
DECLARE_PER_CPU(u64, cpu_softirq_time);
|
|
|
|
|
|
|
|
|
|
#ifndef CONFIG_64BIT
|
|
|
|
|
DECLARE_PER_CPU(seqcount_t, irq_time_seq);
|
|
|
|
|
|
|
|
|
|
static inline void irq_time_write_begin(void)
|
|
|
|
|
{
|
|
|
|
|
__this_cpu_inc(irq_time_seq.sequence);
|
|
|
|
|
smp_wmb();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irq_time_write_end(void)
|
|
|
|
|
{
|
|
|
|
|
smp_wmb();
|
|
|
|
|
__this_cpu_inc(irq_time_seq.sequence);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline u64 irq_time_read(int cpu)
|
|
|
|
|
{
|
|
|
|
|
u64 irq_time;
|
|
|
|
|
unsigned seq;
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
seq = read_seqcount_begin(&per_cpu(irq_time_seq, cpu));
|
|
|
|
|
irq_time = per_cpu(cpu_softirq_time, cpu) +
|
|
|
|
|
per_cpu(cpu_hardirq_time, cpu);
|
|
|
|
|
} while (read_seqcount_retry(&per_cpu(irq_time_seq, cpu), seq));
|
|
|
|
|
|
|
|
|
|
return irq_time;
|
|
|
|
|
}
|
|
|
|
|
#else /* CONFIG_64BIT */
|
|
|
|
|
static inline void irq_time_write_begin(void)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline void irq_time_write_end(void)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline u64 irq_time_read(int cpu)
|
|
|
|
|
{
|
|
|
|
|
return per_cpu(cpu_softirq_time, cpu) + per_cpu(cpu_hardirq_time, cpu);
|
|
|
|
|
}
|
|
|
|
|
#endif /* CONFIG_64BIT */
|
|
|
|
|
#endif /* CONFIG_IRQ_TIME_ACCOUNTING */
|
