sched, deadline: patches
Subsystems (13)
Peter Zijlstra
maintainercover sched, deadline: patches
Hai..
This is my current queue of SCHED_DEADLINE; which I hope to merge 'soon'.
Juri handed me a version that should've (didn't check) included all feedback including the new sched_attr interface.
I did clean up some of the patches; moved some hunks around so that each patch compiles on its own etc..
I then did a number of patches at the end to change some actual stuff around.
Juri do you have some userspace around to test with? I'm just too likely to have wrecked everything; so if you don't have something I need to go write something before merging this :-)
No need to update your test proglets to the new interface, I can lift it if that is more convenient -- I know you're conferencing atm.
One question; the SoB chain in patch 2/13 seems weird; I suppose that patch is a collaborative effort? could we cure that by mentioning Fabio and Michael in some other way?
Peter Zijlstra
maintainerPATCH 1/13 sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
From: Dario Faggioli <[email protected]>
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_setscheduler2(), 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.
--- arch/arm/include/asm/unistd.h | 2 arch/arm/include/uapi/asm/unistd.h | 3 arch/arm/kernel/calls.S | 3 arch/x86/syscalls/syscall_32.tbl | 3 arch/x86/syscalls/syscall_64.tbl | 3 include/linux/sched.h | 54 ++++++++ include/linux/syscalls.h | 8 + kernel/sched/core.c | 234 +++++++++++++++++++++++++++++++++++-- 8 files changed, 298 insertions(+), 12 deletions(-)
arch/arm/include/asm/unistd.h +1 -1
@@ -15,7 +15,7 @@#include <uapi/asm/unistd.h> -#define __NR_syscalls (380) +#define __NR_syscalls (383)#define __ARM_NR_cmpxchg (__ARM_NR_BASE+0x00fff0)#define __ARCH_WANT_STAT64
arch/arm/include/uapi/asm/unistd.h +3 -0
@@ -406,6 +406,9 @@#define __NR_process_vm_writev (__NR_SYSCALL_BASE+377)#define __NR_kcmp (__NR_SYSCALL_BASE+378)#define __NR_finit_module (__NR_SYSCALL_BASE+379) +#define __NR_sched_setscheduler2 (__NR_SYSCALL_BASE+380) +#define __NR_sched_setattr (__NR_SYSCALL_BASE+381) +#define __NR_sched_getattr (__NR_SYSCALL_BASE+382)/* * This may need to be greater than __NR_last_syscall+1 in order to
arch/arm/kernel/calls.S +3 -0
@@ -389,6 +389,9 @@ CALL(sys_process_vm_writev) CALL(sys_kcmp) CALL(sys_finit_module) +/* 380 */ CALL(sys_sched_setscheduler2) + CALL(sys_sched_setattr) + CALL(sys_sched_getattr) #ifndef syscalls_counted .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls #define syscalls_counted
arch/x86/syscalls/syscall_32.tbl +3 -0
@@ -357,3 +357,6 @@ 348 i386 process_vm_writev sys_process_vm_writev compat_sys_process_vm_writev 349 i386 kcmp sys_kcmp 350 i386 finit_module sys_finit_module +351 i386 sched_setattr sys_sched_setattr +352 i386 sched_getattr sys_sched_getattr +353 i386 sched_setscheduler2 sys_sched_setscheduler2
arch/x86/syscalls/syscall_64.tbl +3 -0
@@ -320,6 +320,9 @@ 311 64 process_vm_writev sys_process_vm_writev 312 common kcmp sys_kcmp 313 common finit_module sys_finit_module +314 common sched_setattr sys_sched_setattr +315 common sched_getattr sys_sched_getattr +316 common sched_setscheduler2 sys_sched_setscheduler2 # # x32-specific system call numbers start at 512 to avoid cache impact
include/linux/sched.h +54 -0
66 lines not on this page · raw message
include/linux/syscalls.h +8 -0
@@ -38,6 +38,7 @@ struct rlimit;struct rlimit64 ;struct rusage ;struct sched_param ; +struct sched_attr ;struct sel_arg_struct ;struct semaphore ;struct sembuf ;
@@ -277,11 +278,18 @@ asmlinkage long sys_clock_nanosleep(clocasmlinkage long sys_nice (int increment);asmlinkage long sys_sched_setscheduler (pid_t pid,int policy,struct sched_param __user *param); +asmlinkage long sys_sched_setscheduler2 (pid_t pid,int policy, +struct sched_attr __user *attr);asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param); +asmlinkage long sys_sched_setattr (pid_t pid, +struct sched_attr __user *attr);asmlinkage long sys_sched_getscheduler (pid_t pid);asmlinkage long sys_sched_getparam (pid_t pid,struct sched_param __user *param); +asmlinkage long sys_sched_getattr (pid_t pid, +struct sched_attr __user *attr, +unsigned int size);asmlinkage long sys_sched_setaffinity (pid_t pid,unsigned int len,unsigned long __user *user_mask_ptr); asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
kernel/sched/core.c +223 -11
304 lines not on this page · raw message
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Peter, Dario,
Quoted 20 lines · Peter Zijlstra
From: Dario Faggioli <[email protected]>
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_paramwould break the ABI and result in potentially serious compatibility issues with legacy binaries.
Quoted 8 lines
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_setscheduler2(),sched_setattr()andsched_getattr().
Is someone (e.g., one of you) planning to write man pages for the new sched_setattr() and sched_getattr() system calls? (Also, for the future, please CC [email protected] on patches that change the API, then those of us who don't follow LKML get a heads up about upcoming API changes.)
Thanks,
Michael
Quoted 526 lines
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 <[email protected]>Signed-off-by Juri Lelli <[email protected]>[ Twiddled the changelog. ]Signed-off-by Ingo Molnar <[email protected]>Signed-off-by Peter Zijlstra <[email protected]>--- arch/arm/include/asm/unistd.h | 2 arch/arm/include/uapi/asm/unistd.h | 3 arch/arm/kernel/calls.S | 3 arch/x86/syscalls/syscall_32.tbl | 3 arch/x86/syscalls/syscall_64.tbl | 3 include/linux/sched.h | 54 ++++++++ include/linux/syscalls.h | 8 + kernel/sched/core.c | 234 +++++++++++++++++++++++++++++++++++-- 8 files changed, 298 insertions(+), 12 deletions(-)arch/arm/include/asm/unistd.h +1
-1@@ -15,7 +15,7 @@#include <uapi/asm/unistd.h> -#define __NR_syscalls (380) +#define __NR_syscalls (383)#define __ARM_NR_cmpxchg (__ARM_NR_BASE+0x00fff0)#define __ARCH_WANT_STAT64arch/arm/include/uapi/asm/unistd.h +3
-0@@ -406,6 +406,9 @@#define __NR_process_vm_writev (__NR_SYSCALL_BASE+377)#define __NR_kcmp (__NR_SYSCALL_BASE+378)#define __NR_finit_module (__NR_SYSCALL_BASE+379) +#define __NR_sched_setscheduler2 (__NR_SYSCALL_BASE+380) +#define __NR_sched_setattr (__NR_SYSCALL_BASE+381) +#define __NR_sched_getattr (__NR_SYSCALL_BASE+382)/* * This may need to be greater than __NR_last_syscall+1 in order to arch/arm/kernel/calls.S +3
-0@@ -389,6 +389,9 @@ CALL(sys_process_vm_writev) CALL(sys_kcmp) CALL(sys_finit_module) +/* 380 */ CALL(sys_sched_setscheduler2) + CALL(sys_sched_setattr) + CALL(sys_sched_getattr) #ifndef syscalls_counted .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls #define syscalls_countedarch/x86/syscalls/syscall_32.tbl +3
-0@@ -357,3 +357,6 @@ 348 i386 process_vm_writev sys_process_vm_writev compat_sys_process_vm_writev 349 i386 kcmp sys_kcmp 350 i386 finit_module sys_finit_module +351 i386 sched_setattr sys_sched_setattr +352 i386 sched_getattr sys_sched_getattr +353 i386 sched_setscheduler2 sys_sched_setscheduler2arch/x86/syscalls/syscall_64.tbl +3
-0@@ -320,6 +320,9 @@ 311 64 process_vm_writev sys_process_vm_writev 312 common kcmp sys_kcmp 313 common finit_module sys_finit_module +314 common sched_setattr sys_sched_setattr +315 common sched_getattr sys_sched_getattr +316 common sched_setscheduler2 sys_sched_setscheduler2 # # x32-specific system call numbers start at 512 to avoid cache impactinclude/linux/sched.h +54
-0@@ -56,6 +56,58 @@ struct sched_param {#include <asm/processor.h> +#define SCHED_ATTR_SIZE_VER0 40/* sizeof first published struct */ + +/* +* Extended scheduling parameters data structure. +* +* This is needed because the original struct sched_param can not be +* altered without introducing ABI issues with legacy applications +* (e.g., in sched_getparam()). +* +* However, the possibility of specifying more than just a priority for +* the tasks may be useful for a wide variety of application fields, e.g., +* multimedia, streaming, automation and control, and many others. +* +* This variant (sched_attr) is meant at describing a so-called +* sporadic time-constrained task. In such model a task is specified by: +* - the activation period or minimum instance inter-arrival time; +* - the maximum (or average, depending on the actual scheduling +* discipline) computation time of all instances, a.k.a. runtime; +* - the deadline (relative to the actual activation time) of each +* instance. +* Very briefly, a periodic (sporadic) task asks for the execution of +* some specific computation --which is typically called an instance-- +* (at most) every period. Moreover, each instance typically lasts no more +* than the runtime and must be completed by time instant t equal to +* the instance activation time + the deadline. +* +* This is reflected by the actual fields of the sched_attr structure: +* +* @sched_priority task's priority (might still be useful) +* @sched_flags for customizing the scheduler behaviour +* @sched_deadline representative of the task's deadline +* @sched_runtime representative of the task's runtime +* @sched_period representative of the task's period +* +* Given this task model, there are a multiplicity of scheduling algorithms +* and policies, that can be used to ensure all the tasks will make their +* timing constraints. +* +* @size size of the structure, for fwd/bwd compat. +*/ +struct sched_attr { +int sched_priority; +unsigned int sched_flags; +u64 sched_runtime; +u64 sched_deadline; +u64 sched_period; +u32 size; + +/* Align to u64. */ +u32 __reserved; +}; +struct exec_domain ;struct futex_pi_state ;struct robust_list_head ;@@ -1960,6 +2012,8 @@ extern int sched_setscheduler(struct tas const struct sched_param *);extern int sched_setscheduler_nocheck (struct task_struct *,int ,const struct sched_param *); +extern int sched_setscheduler2 (struct task_struct *,int , +const struct sched_attr *);extern struct task_struct *idle_task (int cpu);/** * is_idle_task - is the specified task an idle task? include/linux/syscalls.h +8
-0@@ -38,6 +38,7 @@ struct rlimit;struct rlimit64 ;struct rusage ;struct sched_param ; +struct sched_attr ;struct sel_arg_struct ;struct semaphore ;struct sembuf ;@@ -277,11 +278,18 @@ asmlinkage long sys_clock_nanosleep(clocasmlinkage long sys_nice (int increment);asmlinkage long sys_sched_setscheduler (pid_t pid,int policy,struct sched_param __user *param); +asmlinkage long sys_sched_setscheduler2 (pid_t pid,int policy, +struct sched_attr __user *attr);asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param); +asmlinkage long sys_sched_setattr (pid_t pid, +struct sched_attr __user *attr);asmlinkage long sys_sched_getscheduler (pid_t pid);asmlinkage long sys_sched_getparam (pid_t pid,struct sched_param __user *param); +asmlinkage long sys_sched_getattr (pid_t pid, +struct sched_attr __user *attr, +unsigned int size);asmlinkage long sys_sched_setaffinity (pid_t pid,unsigned int len,unsigned long __user *user_mask_ptr); asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,kernel/sched/core.c +223
-12@@ -3023,7 +3023,8 @@ static bool check_same_owner(struct task }static int __sched_setscheduler (struct task_struct *p,int policy, -const struct sched_param *param,bool user) +const struct sched_attr *attr, +bool user) {int retval, oldprio, oldpolicy =-1 , on_rq, running;unsigned long flags;@@ -3053,11 +3054,11 @@ static int __sched_setscheduler(struct t* 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL, * SCHED_BATCH and SCHED_IDLE is 0. */ -if (param->sched_priority <0 || - (p->mm && param->sched_priority >MAX_USER_RT_PRIO -1 ) || - (!p->mm && param->sched_priority >MAX_RT_PRIO -1 )) +if (attr->sched_priority <0 || + (p->mm && attr->sched_priority >MAX_USER_RT_PRIO -1 ) || + (!p->mm && attr->sched_priority >MAX_RT_PRIO -1 ))return -EINVAL ; -if (rt_policy (policy) != (param->sched_priority !=0 )) +if (rt_policy (policy) != (attr->sched_priority !=0 ))return -EINVAL ;/* @@ -3073,8 +3074,8 @@ static int __sched_setscheduler(struct treturn -EPERM ;/* can't increase priority */ -if (param->sched_priority > p->rt_priority && - param->sched_priority > rlim_rtprio) +if (attr->sched_priority > p->rt_priority && + attr->sched_priority > rlim_rtprio)return -EPERM ; }@@ -3123,7 +3124,7 @@ static int __sched_setscheduler(struct t* If not changing anything there's no need to proceed further: */ if (unlikely (policy == p->policy && (!rt_policy (policy) || - param->sched_priority == p->rt_priority))) { + attr->sched_priority == p->rt_priority))) {task_rq_unlock (rq, p, &flags);return 0 ; }@@ -3160,7 +3161,7 @@ static int __sched_setscheduler(struct t oldprio = p->prio; prev_class = p->sched_class; -__setscheduler (rq, p, policy, param->sched_priority); +__setscheduler (rq, p, policy, attr->sched_priority);if (running) p->sched_class->set_curr_task (rq);@@ -3188,10 +3189,20 @@ static int __sched_setscheduler(struct tint sched_setscheduler (struct task_struct *p,int policy,const struct sched_param *param) { -return __sched_setscheduler (p, policy, param, true); +struct sched_attr attr = { + .sched_priority = param->sched_priority + }; +return __sched_setscheduler (p, policy, &attr, true); }EXPORT_SYMBOL_GPL (sched_setscheduler); +int sched_setscheduler2 (struct task_struct *p,int policy, +const struct sched_attr *attr) +{ +return __sched_setscheduler (p, policy, attr, true); +} +EXPORT_SYMBOL_GPL (sched_setscheduler2); +/** * sched_setscheduler_nocheck - change the scheduling policy and/or RT priority of a thread from kernelspace. * @p: the task in question. @@ -3208,7 +3219,10 @@ EXPORT_SYMBOL_GPL(sched_setscheduler);int sched_setscheduler_nocheck (struct task_struct *p,int policy,const struct sched_param *param) { -return __sched_setscheduler (p, policy, param, false); +struct sched_attr attr = { + .sched_priority = param->sched_priority + }; +return __sched_setscheduler (p, policy, &attr, false); } static int@@ -3233,6 +3247,97 @@ do_sched_setscheduler(pid_t pid, int polreturn retval; } +/* +* Mimics kernel/events/core.c perf_copy_attr(). +*/ +static int sched_copy_attr (struct sched_attr __user *uattr, +struct sched_attr *attr) +{ +u32 size; +int ret; + +if (!access_ok (VERIFY_WRITE , uattr,SCHED_ATTR_SIZE_VER0 )) +return -EFAULT ; + +/* +* zero the full structure, so that a short copy will be nice. +*/ +memset (attr,0 ,sizeof (*attr)); + + ret =get_user (size, &uattr->size); +if (ret) +return ret; + +if (size >PAGE_SIZE )/* silly large */ + goto err_size; + +if (!size)/* abi compat */ + size =SCHED_ATTR_SIZE_VER0 ; + +if (size <SCHED_ATTR_SIZE_VER0 ) + goto err_size; + +/* +* If we're handed a bigger struct than we know of, +* ensure all the unknown bits are 0 - i.e. new +* user-space does not rely on any kernel feature +* extensions we dont know about yet. +*/ +if (size >sizeof (*attr)) { +unsigned char __user *addr; +unsigned char __user *end; +unsigned char val; + + addr = (void __user *)uattr +sizeof (*attr); + end = (void __user *)uattr + size; + +for (; addr < end; addr++) { + ret =get_user (val, addr); +if (ret) +return ret; +if (val) + goto err_size; + } + size =sizeof (*attr); + } + + ret =copy_from_user (attr, uattr, size); +if (ret) +return -EFAULT ; + +out: +return ret; + +err_size: +put_user (sizeof (*attr), &uattr->size); + ret = -E2BIG ; + goto out; +} + +static int +do_sched_setscheduler2 (pid_t pid,int policy, +struct sched_attr __user *attr_uptr) +{ +struct sched_attr attr; +struct task_struct *p; +int retval; + +if (!attr_uptr || pid <0 ) +return -EINVAL ; + +if (sched_copy_attr (attr_uptr, &attr)) +return -EFAULT ; + +rcu_read_lock (); + retval = -ESRCH ; + p =find_process_by_pid (pid); +if (p !=NULL ) + retval =sched_setscheduler2 (p, policy, &attr); +rcu_read_unlock (); + +return retval; +} +/** * sys_sched_setscheduler - set/change the scheduler policy and RT priority * @pid: the pid in question. @@ -3252,6 +3357,21 @@ SYSCALL_DEFINE3(sched_setscheduler, pid_ }/** +* sys_sched_setscheduler2 - same as above, but with extended sched_param +* @pid: the pid in question. +* @policy: new policy (could use extended sched_param). +* @attr: structure containg the extended parameters. +*/ +SYSCALL_DEFINE3 (sched_setscheduler2, pid_t, pid, int, policy, + struct sched_attr __user *, attr) +{ +if (policy <0 ) +return -EINVAL ; + +return do_sched_setscheduler2 (pid, policy, attr); +} + +/** * sys_sched_setparam - set/change the RT priority of a thread * @pid: the pid in question. * @param: structure containing the new RT priority. @@ -3264,6 +3384,17 @@ SYSCALL_DEFINE2(sched_setparam, pid_t, p }/** +* sys_sched_setattr - same as above, but with extended sched_attr +* @pid: the pid in question. +* @attr: structure containing the extended parameters. +*/ +SYSCALL_DEFINE2 (sched_setattr, pid_t, pid, + struct sched_attr __user *, attr) +{ +return do_sched_setscheduler2 (pid,-1 , attr); +} + +/** * sys_sched_getscheduler - get the policy (scheduling class) of a thread * @pid: the pid in question. * @@ -3329,6 +3460,87 @@ SYSCALL_DEFINE2(sched_getparam, pid_t, preturn retval; out_unlock: +rcu_read_unlock (); +return retval; +} + +static int sched_read_attr (struct sched_attr __user *uattr, +struct sched_attr *attr, +unsigned int usize) +{ +int ret; + +if (!access_ok (VERIFY_WRITE , uattr, usize)) +return -EFAULT ; + +/* +* If we're handed a smaller struct than we know of, +* ensure all the unknown bits are 0 - i.e. old +* user-space does not get uncomplete information. +*/ +if (usize <sizeof (*attr)) { +unsigned char *addr; +unsigned char *end; + + addr = (void *)attr + usize; + end = (void *)attr +sizeof (*attr); + +for (; addr < end; addr++) { +if (*addr) + goto err_size; + } + + attr->size = usize; + } + + ret =copy_to_user (uattr, attr, usize); +if (ret) +return -EFAULT ; + +out: +return ret; + +err_size: + ret = -E2BIG ; + goto out; +} + +/** +* sys_sched_getattr - same as above, but with extended "sched_param" +* @pid: the pid in question. +* @attr: structure containing the extended parameters. +* @size: sizeof(attr) for fwd/bwd comp. +*/ +SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned int, size) +{ +struct sched_attr attr = { + .size =sizeof (struct sched_attr ), + }; +struct task_struct *p; +int retval; + +if (!uattr || pid <0 || size >PAGE_SIZE || + size <SCHED_ATTR_SIZE_VER0 ) +return -EINVAL ; + +rcu_read_lock (); + p =find_process_by_pid (pid); + retval = -ESRCH ; +if (!p) + goto out_unlock; + + retval =security_task_getscheduler (p); +if (retval) + goto out_unlock; + + attr.sched_priority = p->rt_priority; +rcu_read_unlock (); + + retval =sched_read_attr (uattr, &attr, size); +return retval; + +out_unlock:rcu_read_unlock ();return retval; } --To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Author of "The Linux Programming Interface", http://blog.man7.org/
Peter Zijlstra
maintainerRe: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 7 lines · Michael Kerrisk
Peter, Dario,
Is someone (e.g., one of you) planning to write man pages for the new
sched_setattr()andsched_getattr()system calls? (Also, for the future, please CC [email protected] on patches that change the API, then those of us who don't follow LKML get a heads up about upcoming API changes.)
first draft, shamelessly stolen from SCHED_SETSCHEDULER(2).
One note on both the original as well as the below: process is ambiguous, the syscalls actually apply to a single thread of a process, not the entire process.
---
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid. If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a first-in, first-out policy;
SCHED_RR a round-robin policy; and
SCHED_DEADLINE a deadline policy.
The semantics of each of these policies are detailed below.
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see NICE(2).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtime sched_attr::sched_deadline
sched_attr::sched_period should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The other sched_attr fields are filled out as described in sched_setattr().
${insert SCHED_* descriptions}
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of other SCHED_DEADLINE tasks.
SCHED_DEADLINE tasks will fail FORK(2) with -EAGAIN
Setting SCHED_DEADLINE can fail with -EINVAL when admission control tests fail.
${NOTE: should we change that to -EBUSY ? }
Other than that its pretty much the same as the existing SCHED_SETSCHEDULER(2) page.
Peter Zijlstra
maintainerRe: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 3 lines · Peter Zijlstra
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).
We might want to re-word that to:
SCHED_DEADLINE currently is an implementation of GEDF, however any policy that correctly schedules the sporadic task model is a valid implementation.
To make sure we should not rely on the actual implementation; there's many possible algorithms to schedule the sporadic task model.
Quoted 9 lines
The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of other
SCHED_DEADLINEtasks.
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.
Steven Rostedt
maintainerRe: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 5 lines · On Tue, 21 Jan 2014 16:46:03 +0100 Peter Zijlstra <[email protected]> wrote:
Quoted 3 lines · Peter Zijlstra
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).
Quoted 8 lines
We might want to re-word that to:
SCHED_DEADLINEcurrently is an implementation of GEDF, however any policy that correctly schedules the sporadic task model is a valid implementation.To make sure we should not rely on the actual implementation; there's many possible algorithms to schedule the sporadic task model.
Probably should post some links to GEDF documentation too?
-- Steve
Quoted 10 lines
Quoted 10 lines
The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of other
SCHED_DEADLINEtasks.
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.
Peter Zijlstra
maintainerRe: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 10 lines · Steven Rostedt
Quoted 7 lines · On Tue, 21 Jan 2014 16:46:03 +0100 Peter Zijlstra <[email protected]> wrote:
Quoted 3 lines · Peter Zijlstra
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).We might want to re-word that to:
Quoted 8 lines
Quoted 6 lines
SCHED_DEADLINEcurrently is an implementation of GEDF, however any policy that correctly schedules the sporadic task model is a valid implementation.To make sure we should not rely on the actual implementation; there's many possible algorithms to schedule the sporadic task model.
Probably should post some links to GEDF documentation too?
At best I think we can do something like:
SEE ALSO
Documentation/scheduler/sched_deadline.txt in the Linux kernel source tree (since kernel 3.14).
Possibly also an ISBN for a good scheduling theory book (if there exists such a thing), but I would have to rely on others to provide such as my shelfs are devoid of such material.
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 22 lines · Peter Zijlstra
Quoted 10 lines · Steven Rostedt
Quoted 7 lines · On Tue, 21 Jan 2014 16:46:03 +0100 Peter Zijlstra <[email protected]> wrote:
Quoted 3 lines · Peter Zijlstra
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).We might want to re-word that to:
Quoted 8 lines
Quoted 6 lines
SCHED_DEADLINEcurrently is an implementation of GEDF, however any policy that correctly schedules the sporadic task model is a valid implementation.To make sure we should not rely on the actual implementation; there's many possible algorithms to schedule the sporadic task model.
Probably should post some links to GEDF documentation too?
At best I think we can do something like:
Quoted 8 lines
SEE ALSO
Documentation/scheduler/sched_deadline.txtin the Linux kernel source tree (since kernel 3.14).Possibly also an ISBN for a good scheduling theory book (if there exists such a thing), but I would have to rely on others to provide such as my shelfs are devoid of such material.
Well, picking just one is not that easy, I'd say (among many others):
- Handbook of Scheduling: Algorithms, Models, and Performance Analysis by Joseph Y-T. Leung, James H. Anderson - ISBN-10: 1584883979 (especially cap. 30);
- Hard Real-Time Computing Systems by Giorgio C. Buttazzo
ISBN 978-1-4614-0675-4 (even if it is more about UP);
- A survey of hard real-time scheduling for multiprocessor systems
by RI Davis, A Burns - ACM Computing Surveys (CSUR), 2011 (available at http://www-users.cs.york.ac.uk/~robdavis/papers/MPSurveyv5.0.pdf);
Probably last one is better (as is freely downloadable). We should add something in the documentation too.
Thanks,
- Juri
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
In reply to Peter ZijlstraPeter, Dario,
This is a little late in the day, but I think it's an important point to just check before this API goes final.
Quoted 8 lines
SYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags;
[...]
Quoted 5 lines
};
int sched_setattr(pid_t pid, const struct sched_attr *attr);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size);So, I that there's a flags field in the structure, which allows for some extensibility for these calls in the future. However, is it worthwhile to consider adding a 'flags' argument in the base signature of either of these calls, to allow for some possible extensions in the future. (See http://lwn.net/SubscriberLink/585415/7b905c0248a158a2/ ).
Cheers,
Michael
Peter Zijlstra
maintainerRe: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 18 lines · Michael Kerrisk (man-pages)
Peter, Dario,
This is a little late in the day, but I think it's an important point to just check before this API goes final.
Quoted 8 lines
SYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags;[...]
Quoted 4 lines
}; int sched_setattr(pid_t pid, const struct sched_attr *attr);
Quoted 7 lines
Quoted 1 line
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size);So, I that there's a flags field in the structure, which allows for some extensibility for these calls in the future. However, is it worthwhile to consider adding a 'flags' argument in the base signature of either of these calls, to allow for some possible extensions in the future. (See http://lwn.net/SubscriberLink/585415/7b905c0248a158a2/ ).
Sure why not.. I picked 'unsigned long' for the flags argument; I don't think there's a real standard for this, I've seen: 'int' 'unsigned int' and 'unsigned long' flags.
Please holler if there is indeed a preference and I picked the wrong one.
BTW; do you need more text on the manpage thingy I send you or was that sufficient?
---
Subject: sched: Add 'flags' argument to sched_{set,get}attr() syscalls
Because of a recent syscall design debate; its deemed appropriate for each syscall to have a flags argument for future extension; without immediately requiring new syscalls.
--- include/linux/syscalls.h | 6 ++++-- kernel/sched/core.c | 11 ++++++----- 2 files changed, 10 insertions(+), 7 deletions(-)
include/linux/syscalls.h +4 -2
@@ -281,13 +281,15 @@ asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_setattr (pid_t pid, -struct sched_attr __user *attr); +struct sched_attr __user *attr, +unsigned long flags);asmlinkage long sys_sched_getscheduler (pid_t pid);asmlinkage long sys_sched_getparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_getattr (pid_t pid,struct sched_attr __user *attr, -unsigned int size); +unsigned int size, +unsigned long flags);asmlinkage long sys_sched_setaffinity (pid_t pid,unsigned int len,unsigned long __user *user_mask_ptr); asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
kernel/sched/core.c +6 -5
@@ -3631,13 +3631,14 @@ SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)* @pid: the pid in question. * @uattr: structure containing the extended parameters. */ -SYSCALL_DEFINE2(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr) +SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned long, flags) {struct sched_attr attr;struct task_struct *p;int retval; -if (!uattr || pid <0 ) +if (!uattr || pid <0 || flags)return -EINVAL ;if (sched_copy_attr (uattr, &attr))
@@ -3774,8 +3775,8 @@ static int sched_read_attr(struct sched_attr __user *uattr,* @uattr: structure containing the extended parameters. * @size: sizeof(attr) for fwd/bwd comp. */ -SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, - unsigned int, size) +SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned int, size, unsigned long, flags) {struct sched_attr attr = { .size =sizeof (struct sched_attr ),
@@ -3784,7 +3785,7 @@ SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,int retval;if (!uattr || pid <0 || size >PAGE_SIZE || - size <SCHED_ATTR_SIZE_VER0 ) + size <SCHED_ATTR_SIZE_VER0 || flags)return -EINVAL ;rcu_read_lock ();
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
Quoted 21 lines · Peter Zijlstra
Quoted 13 lines
Quoted 8 lines
SYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags;[...]
Quoted 4 lines
}; int sched_setattr(pid_t pid, const struct sched_attr *attr);Quoted 7 lines
Quoted 1 line
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size);So, I that there's a flags field in the structure, which allows for some extensibility for these calls in the future. However, is it worthwhile to consider adding a 'flags' argument in the base signature of either of these calls, to allow for some possible extensions in the future. (See http://lwn.net/SubscriberLink/585415/7b905c0248a158a2/ ).
Quoted 6 lines
Sure why not.. I picked 'unsigned long' for the flags argument; I don't think there's a real standard for this, I've seen: 'int' 'unsigned int' and 'unsigned long' flags.
Please holler if there is indeed a preference and I picked the wrong one.
Yo!
So, since this is an ABI, if it's a true 64-bit flags value then please make it u64 - and 'unsigned int' or u32 otherwise. I don't think we have many (any?) 'long' argument syscall ABIs.
'unsigned long' is generally a bad choice because it's u32 on 32-bit platforms and u64 on 64-bit platforms.
Now, for syscall argument ABIs it's not a lethal mistake to make (as compared to say ABI data structures), because syscall arguments have their own types and width anyway, so any definition mistake can usually be fixed after the fact.
Thanks,
Ingo
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
In reply to Peter ZijlstraHello Peter,
Quoted 21 lines · Peter Zijlstra
Quoted 20 lines · Michael Kerrisk (man-pages)
Peter, Dario,
This is a little late in the day, but I think it's an important point to just check before this API goes final.
Quoted 8 lines
SYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags;[...]
Quoted 5 lines
}; int sched_setattr(pid_t pid, const struct sched_attr *attr); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size);
Quoted 7 lines
Quoted 5 lines
So, I that there's a flags field in the structure, which allows for some extensibility for these calls in the future. However, is it worthwhile to consider adding a 'flags' argument in the base signature of either of these calls, to allow for some possible extensions in the future. (See http://lwn.net/SubscriberLink/585415/7b905c0248a158a2/ ).
Sure why not..
Well, it doesn't need to be added gratuitously -- just if you think there's some nonzero chance it might prove useful in the future ;-).
Quoted 9 lines
I picked 'unsigned long' for the flags argument; I don't think there's a real standard for this, I've seen: 'int' 'unsigned int' and 'unsigned long' flags.
Please holler if there is indeed a preference and I picked the wrong one.
BTW; do you need more text on the manpage thingy I send you or was that sufficient?
If your could take another pass though your existing text, to incorporate the new flags stuff, and then send a page to me + linux-man@
that would be great.
Cheers,
Michael
Quoted 78 lines
---
Subject: sched: Add 'flags' argument to sched_{set,get}attr() syscallsBecause of a recent syscall design debate; its deemed appropriate for each syscall to have a flags argument for future extension; without immediately requiring new syscalls.
Suggested-by Michael Kerrisk <[email protected]>Signed-off-by Peter Zijlstra <[email protected]>--- include/linux/syscalls.h | 6 ++++-- kernel/sched/core.c | 11 ++++++----- 2 files changed, 10 insertions(+), 7 deletions(-)include/linux/syscalls.h +4
-2@@ -281,13 +281,15 @@ asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_setattr (pid_t pid, -struct sched_attr __user *attr); +struct sched_attr __user *attr, +unsigned long flags);asmlinkage long sys_sched_getscheduler (pid_t pid);asmlinkage long sys_sched_getparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_getattr (pid_t pid,struct sched_attr __user *attr, -unsigned int size); +unsigned int size, +unsigned long flags);asmlinkage long sys_sched_setaffinity (pid_t pid,unsigned int len,unsigned long __user *user_mask_ptr); asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,kernel/sched/core.c +6
-5@@ -3631,13 +3631,14 @@ SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)* @pid: the pid in question. * @uattr: structure containing the extended parameters. */ -SYSCALL_DEFINE2(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr) +SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned long, flags) {struct sched_attr attr;struct task_struct *p;int retval; -if (!uattr || pid <0 ) +if (!uattr || pid <0 || flags)return -EINVAL ;if (sched_copy_attr (uattr, &attr))@@ -3774,8 +3775,8 @@ static int sched_read_attr(struct sched_attr __user *uattr,* @uattr: structure containing the extended parameters. * @size: sizeof(attr) for fwd/bwd comp. */ -SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, - unsigned int, size) +SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned int, size, unsigned long, flags) {struct sched_attr attr = { .size =sizeof (struct sched_attr ),@@ -3784,7 +3785,7 @@ SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,int retval;if (!uattr || pid <0 || size >PAGE_SIZE || - size <SCHED_ATTR_SIZE_VER0 ) + size <SCHED_ATTR_SIZE_VER0 || flags)return -EINVAL ;rcu_read_lock ();
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
Peter Zijlstra
maintainersched_{set,get}attr() manpage
Quoted 3 lines · Michael Kerrisk (man-pages)
If your could take another pass though your existing text, to incorporate the new flags stuff, and then send a page to me + linux-man@
that would be great.
Sorry, this slipped my mind. An updated version below. Heavy borrowing from SCHED_SETSCHEDULER(2) as before.
---
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid. If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a first-in, first-out policy;
SCHED_RR a round-robin policy; and
SCHED_DEADLINE a deadline policy.
The semantics of each of these policies are detailed below.
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see NICE(2).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtime sched_attr::sched_deadline
sched_attr::sched_period should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters.
The flags argument should be 0.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The flags argument should be 0.
The other sched_attr fields are filled out as described in sched_setattr().
Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified by sched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.
For processes scheduled under one of the normal scheduling policies (SCHED_OTHER, SCHED_IDLE, SCHED_BATCH), sched_priority is not used in scheduling decisions (it must be specified as 0).
Processes scheduled under one of the real-time policies (SCHED_FIFO, SCHED_RR) have a sched_priority value in the range 1 (low) to 99 (high). (As the numbers imply, real-time processes always have higher priority than normal processes.) Note well: POSIX.1-2001 only requires an implementation to support a minimum 32 distinct priority levels for the real-time policies, and some systems supply just this minimum.
Portable programs should use sched_get_priority_min(2) and
sched_get_priority_max(2) to find the range of priorities supported for a particular policy.
Conceptually, the scheduler maintains a list of runnable processes for
each possible sched_priority value. In order to determine which
process runs next, the scheduler looks for the nonempty list with the highest static priority and selects the process at the head of this list.
A process's scheduling policy determines where it will be inserted into the list of processes with equal static priority and how it will move inside this list.
All scheduling is preemptive: if a process with a higher static prior‐ ity becomes ready to run, the currently running process will be pre‐ empted and returned to the wait list for its static priority level. The scheduling policy only determines the ordering within the list of runnable processes with equal static priority.
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of other SCHED_DEADLINE tasks.
SCHED_DEADLINE tasks will fail FORK(2) with -EAGAIN
Setting SCHED_DEADLINE can fail with -EINVAL when admission control tests fail.
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFO can only be used with static priorities higher than 0, which means that when a SCHED_FIFO processes becomes runnable, it will always immediately preempt any currently running SCHED_OTHER, SCHED_BATCH, or SCHED_IDLE process. SCHED_FIFO is a simple scheduling algorithm with‐ out time slicing. For processes scheduled under the SCHED_FIFO policy, the following rules apply:
* A SCHED_FIFO process that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.
* When a SCHED_FIFO process becomes runnable, it will be inserted at the end of the list for its priority.
* A call to sched_setscheduler() or sched_setparam(2) will put the SCHED_FIFO (or SCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)
* A process calling sched_yield(2) will be put at the end of the list.
No other events will move a process scheduled under the SCHED_FIFO pol‐ icy in the wait list of runnable processes with equal static priority.
A SCHED_FIFO process runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).
SCHED_RR: Round Robin scheduling
SCHED_RR is a simple enhancement of SCHED_FIFO. Everything described above for SCHED_FIFO also applies to SCHED_RR, except that each process is only allowed to run for a maximum time quantum. If a SCHED_RR process has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. A SCHED_RR process that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved using sched_rr_get_interval(2).
SCHED_OTHER: Default Linux time-sharing scheduling
SCHED_OTHER can only be used at static priority 0. SCHED_OTHER is the standard Linux time-sharing scheduler that is intended for all pro‐ cesses that do not require the special real-time mechanisms. The process to run is chosen from the static priority 0 list based on a dynamic priority that is determined only inside this list. The dynamic priority is based on the nice value (set by nice(2) or setpriority(2)) and increased for each time quantum the process is ready to run, but denied to run by the scheduler. This ensures fair progress among all SCHED_OTHER processes.
SCHED_BATCH: Scheduling batch processes
(Since Linux 2.6.16.) SCHED_BATCH can only be used at static priority
0. This policy is similar to SCHED_OTHER in that it schedules the process according to its dynamic priority (based on the nice value). The difference is that this policy will cause the scheduler to always assume that the process is CPU-intensive. Consequently, the scheduler will apply a small scheduling penalty with respect to wakeup behaviour, so that this process is mildly disfavored in scheduling decisions.
This policy is useful for workloads that are noninteractive, but do not want to lower their nice value, and for workloads that want a determin‐ istic scheduling policy without interactivity causing extra preemptions (between the workload's tasks).
SCHED_IDLE: Scheduling very low priority jobs
(Since Linux 2.6.23.) SCHED_IDLE can only be used at static priority 0; the process nice value has no influence for this policy.
This policy is intended for running jobs at extremely low priority (lower even than a +19 nice value with the SCHED_OTHER or SCHED_BATCH policies).
RETURN VALUE
On success, sched_setattr() and sched_getattr() return 0. On error, -1 is returned, and errno is set appropriately.
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct sched_attr is either too
big, see sched_setattr(), or too small, see sched_getattr().
NOTES
While the text above (and in SCHED_SETSCHEDULER(2)) talks about processes, in actual fact these system calls are thread specific.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: sched_{set,get}attr() manpage
Quoted 44 lines · Peter Zijlstra
Quoted 3 lines · Michael Kerrisk (man-pages)
If your could take another pass though your existing text, to incorporate the new flags stuff, and then send a page to me + linux-man@
that would be great.Sorry, this slipped my mind. An updated version below. Heavy borrowing from
SCHED_SETSCHEDULER(2)as before.---
NAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid. If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
Quoted 7 lines
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for
why the "'s?
Quoted 55 lines
special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa first-in, first-out policy;
SCHED_RRa round-robin policy; and
SCHED_DEADLINEa deadline policy.The semantics of each of these policies are detailed below.
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see NICE(2).
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtimesched_attr::sched_deadline
sched_attr::sched_periodshould only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters.The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.
Quoted 1 line
The flags argument should be 0.
What about SCHED_FLAG_RESET_ON_FOR?
Quoted 10 lines
The other
sched_attrfields are filled out as described insched_setattr().Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.
Isn't this last sentence redundant/sliglhtly repetitive?
Quoted 37 lines
For processes scheduled under one of the normal scheduling policies (
SCHED_OTHER,SCHED_IDLE,SCHED_BATCH),sched_priorityis not used in scheduling decisions (it must be specified as 0).Processes scheduled under one of the real-time policies (
SCHED_FIFO,SCHED_RR) have asched_priorityvalue in the range 1 (low) to 99 (high). (As the numbers imply, real-time processes always have higher priority than normal processes.) Note well: POSIX.1-2001 only requires an implementation to support a minimum 32 distinct priority levels for the real-time policies, and some systems supply just this minimum.
Portable programs should usesched_get_priority_min(2)and
sched_get_priority_max(2)to find the range of priorities supported for a particular policy.Conceptually, the scheduler maintains a list of runnable processes for
each possiblesched_priorityvalue. In order to determine which
process runs next, the scheduler looks for the nonempty list with the highest static priority and selects the process at the head of this list.A process's scheduling policy determines where it will be inserted into the list of processes with equal static priority and how it will move inside this list.
All scheduling is preemptive: if a process with a higher static prior‐ ity becomes ready to run, the currently running process will be pre‐ empted and returned to the wait list for its static priority level. The scheduling policy only determines the ordering within the list of runnable processes with equal static priority.
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.
Quoted 4 lines
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.
Perhaps add a note about the deadline-class having higher priority than the other classes; i.e. if a deadline-task is runnable, it will preempt any other SCHED_(RR|FIFO) regardless of priority?
Quoted 16 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.
Quoted 8 lines
* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)* A process calling
sched_yield(2)will be put at the end of the list.
How about the recent discussion regarding sched_yield(). Is this correct?
lkml.kernel.org/r/alpine.DEB.2.02.1403312333100.14882-3cz04HxQygjZikZi3RtOZ2GXanvQGlWp@public.gmane.orgnix.de
Is this the correct place to add a note explaining te potentional pitfalls using sched_yield?
Quoted 7 lines
No other events will move a process scheduled under the
SCHED_FIFOpol‐ icy in the wait list of runnable processes with equal static priority.A
SCHED_FIFOprocess runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).
Quoted 10 lines
SCHED_RR: Round Robin scheduling
SCHED_RRis a simple enhancement ofSCHED_FIFO. Everything described above forSCHED_FIFOalso applies toSCHED_RR, except that each process is only allowed to run for a maximum time quantum. If aSCHED_RRprocess has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. ASCHED_RRprocess that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved usingsched_rr_get_interval(2).
-> Default is 0.1HZ ms
This is a question I get form time to time, having this in the manpage would be helpful.
Quoted 41 lines
SCHED_OTHER: Default Linux time-sharing scheduling
SCHED_OTHERcan only be used at static priority 0.SCHED_OTHERis the standard Linux time-sharing scheduler that is intended for all pro‐ cesses that do not require the special real-time mechanisms. The process to run is chosen from the static priority 0 list based on a dynamic priority that is determined only inside this list. The dynamic priority is based on the nice value (set by nice(2) or setpriority(2)) and increased for each time quantum the process is ready to run, but denied to run by the scheduler. This ensures fair progress among allSCHED_OTHERprocesses.
SCHED_BATCH: Scheduling batch processes
(Since Linux 2.6.16.)SCHED_BATCHcan only be used at static priority
0. This policy is similar toSCHED_OTHERin that it schedules the process according to its dynamic priority (based on the nice value). The difference is that this policy will cause the scheduler to always assume that the process is CPU-intensive. Consequently, the scheduler will apply a small scheduling penalty with respect to wakeup behaviour, so that this process is mildly disfavored in scheduling decisions.This policy is useful for workloads that are noninteractive, but do not want to lower their nice value, and for workloads that want a determin‐ istic scheduling policy without interactivity causing extra preemptions (between the workload's tasks).
SCHED_IDLE: Scheduling very low priority jobs
(Since Linux 2.6.23.)SCHED_IDLEcan only be used at static priority 0; the process nice value has no influence for this policy.This policy is intended for running jobs at extremely low priority (lower even than a +19 nice value with the
SCHED_OTHERorSCHED_BATCHpolicies).RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.
Quoted 6 lines
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().
Where's the EBUSY? It can throw this from __sched_setscheduler() when it checks if there's enough bandwidth to run the task.
Quoted 4 lines
NOTES
While the text above (and inSCHED_SETSCHEDULER(2)) talks about processes, in actual fact these system calls are thread specific.
Signature · 5 lines
Henrik Austad -- To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 3 lines · Henrik Austad
Quoted 1 line
The following "real-time" policies are also supported, for
why the "'s?
I borrowed those from SCHED_SETSCHEDULER(2).
Quoted 8 lines
Quoted 8 lines
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
...
Quoted 3 lines
Quoted 1 line
The flags argument should be 0.
What about
SCHED_FLAG_RESET_ON_FOR?
Different flags. The one is sched_attr::flags the other is sched_setattr(.flags).
Quoted 11 lines
Quoted 10 lines
The other
sched_attrfields are filled out as described insched_setattr().Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.
Quoted 1 line
Isn't this last sentence redundant/sliglhtly repetitive?
I borrowed that from SCHED_SETSCHEDULER(2) again.
Quoted 7 lines
Quoted 7 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.
Quoted 8 lines
Quoted 4 lines
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.Perhaps add a note about the deadline-class having higher priority than the other classes; i.e. if a deadline-task is runnable, it will preempt any other
SCHED_(RR|FIFO)regardless of priority?
Yes, good point, will do.
Quoted 23 lines
Quoted 23 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)
Quoted 8 lines
Quoted 1 line
* A process calling
sched_yield(2)will be put at the end of the list.How about the recent discussion regarding
sched_yield(). Is this correct?lkml.kernel.org/r/alpine.DEB.2.02.1403312333100.14882-3cz04HxQyghirQl2xIGP3A@public.gmane.orgronix.de
Is this the correct place to add a note explaining te potentional pitfalls using
sched_yield?
I'm not sure; there's a SCHED_YIELD(2) manpage to fill with that nonsense.
Also; I realized I have not described the DEADLINE sched_yield() behaviour.
Quoted 18 lines
Quoted 7 lines
No other events will move a process scheduled under the
SCHED_FIFOpol‐ icy in the wait list of runnable processes with equal static priority.A
SCHED_FIFOprocess runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).Quoted 10 lines
SCHED_RR: Round Robin scheduling
SCHED_RRis a simple enhancement ofSCHED_FIFO. Everything described above forSCHED_FIFOalso applies toSCHED_RR, except that each process is only allowed to run for a maximum time quantum. If aSCHED_RRprocess has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. ASCHED_RRprocess that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved usingsched_rr_get_interval(2).
Quoted 4 lines
-> Default is 0.1HZ ms
This is a question I get form time to time, having this in the manpage would be helpful.
Again, brazenly stolen from SCHED_SETSCHEDULER(2); but yes. Also I'm not sure I'd call RR an enhancement of anything much at all ;-)
Quoted 6 lines
Quoted 6 lines
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.EPERM The calling process does not have appropriate privileges.
Quoted 7 lines
Quoted 4 lines
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().Where's the EBUSY? It can throw this from
__sched_setscheduler()when it checks if there's enough bandwidth to run the task.
Uhhm.. it got lost :-) /me quickly adds.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: sched_{set,get}attr() manpage
Hi all,
Quoted 87 lines · On Wed, 9 Apr 2014 17:42:04 +0200 Peter Zijlstra <[email protected]> wrote:
Quoted 3 lines · Henrik Austad
Quoted 1 line
The following "real-time" policies are also supported, for
why the "'s?
I borrowed those from
SCHED_SETSCHEDULER(2).Quoted 8 lines
Quoted 8 lines
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
...
Quoted 3 lines
Quoted 1 line
The flags argument should be 0.
What about
SCHED_FLAG_RESET_ON_FOR?Different flags. The one is
sched_attr::flagsthe other issched_setattr(.flags).Quoted 11 lines
Quoted 10 lines
The other
sched_attrfields are filled out as described insched_setattr().Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.Quoted 1 line
Isn't this last sentence redundant/sliglhtly repetitive?
I borrowed that from
SCHED_SETSCHEDULER(2)again.Quoted 7 lines
Quoted 7 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.Quoted 8 lines
Quoted 4 lines
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.Perhaps add a note about the deadline-class having higher priority than the other classes; i.e. if a deadline-task is runnable, it will preempt any other
SCHED_(RR|FIFO)regardless of priority?Yes, good point, will do.
Quoted 29 lines
Quoted 16 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.Quoted 8 lines
* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)* A process calling
sched_yield(2)will be put at the end of the list.How about the recent discussion regarding
sched_yield(). Is this correct?lkml.kernel.org/r/[email protected]
Quoted 9 lines
Quoted 2 lines
Is this the correct place to add a note explaining te potentional pitfalls using
sched_yield?I'm not sure; there's a
SCHED_YIELD(2)manpage to fill with that nonsense.Also; I realized I have not described the DEADLINE
sched_yield()behaviour.
So, for SCHED_DEADLINE we currently have this behaviour:
/*
* Yield task semantic for -deadline tasks is:
*
* get off from the CPU until our next instance, with * a new runtime. This is of little use now, since we * don't have a bandwidth reclaiming mechanism. Anyway, * bandwidth reclaiming is planned for the future, and * yield_task_dl will indicate that some spare budget * is available for other task instances to use it.
*/
But, considering also the discussion above, I'm less sure now that's what we want. Still, I think we will want some way in the future to be able to say "I'm finished with my current job, give this remaining runtime to someone else", like another syscall or something.
Thanks,
- Juri
Quoted 41 lines
Quoted 18 lines
Quoted 7 lines
No other events will move a process scheduled under the
SCHED_FIFOpol‐ icy in the wait list of runnable processes with equal static priority.A
SCHED_FIFOprocess runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).Quoted 10 lines
SCHED_RR: Round Robin scheduling
SCHED_RRis a simple enhancement ofSCHED_FIFO. Everything described above forSCHED_FIFOalso applies toSCHED_RR, except that each process is only allowed to run for a maximum time quantum. If aSCHED_RRprocess has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. ASCHED_RRprocess that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved usingsched_rr_get_interval(2).Quoted 4 lines
-> Default is 0.1HZ ms
This is a question I get form time to time, having this in the manpage would be helpful.
Again, brazenly stolen from
SCHED_SETSCHEDULER(2); but yes. Also I'm not sure I'd call RR an enhancement of anything much at all ;-)Quoted 6 lines
Quoted 6 lines
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.EPERM The calling process does not have appropriate privileges.
Quoted 7 lines
Quoted 4 lines
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().Where's the EBUSY? It can throw this from
__sched_setscheduler()when it checks if there's enough bandwidth to run the task.Uhhm.. it got lost :-) /me quickly adds.
Re: sched_{set,get}attr() manpage
Il 10/04/2014 09:47, Juri Lelli ha scritto:
Quoted 101 lines
Hi all,
Quoted 77 lines · On Wed, 9 Apr 2014 17:42:04 +0200 Peter Zijlstra <[email protected]> wrote:
Quoted 2 lines · Henrik Austad
Quoted 1 line
The following "real-time" policies are also supported, for
why the "'s?
I borrowed those from
SCHED_SETSCHEDULER(2).Quoted 8 lines
Quoted 8 lines
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
...
Quoted 2 lines
Quoted 1 line
The flags argument should be 0.
What about
SCHED_FLAG_RESET_ON_FOR?Different flags. The one is
sched_attr::flagsthe other issched_setattr(.flags).Quoted 11 lines
Quoted 10 lines
The other
sched_attrfields are filled out as described insched_setattr().Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.Isn't this last sentence redundant/sliglhtly repetitive?
I borrowed that from
SCHED_SETSCHEDULER(2)again.Quoted 7 lines
Quoted 7 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.Quoted 7 lines
Quoted 4 lines
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.Perhaps add a note about the deadline-class having higher priority than the other classes; i.e. if a deadline-task is runnable, it will preempt any other
SCHED_(RR|FIFO)regardless of priority?Yes, good point, will do.
Quoted 28 lines
Quoted 16 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.Quoted 8 lines
* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)* A process calling
sched_yield(2)will be put at the end of the list.How about the recent discussion regarding
sched_yield(). Is this correct?lkml.kernel.org/r/[email protected]
Quoted 8 lines
Quoted 2 lines
Is this the correct place to add a note explaining te potentional pitfalls using
sched_yield?I'm not sure; there's a
SCHED_YIELD(2)manpage to fill with that nonsense.Also; I realized I have not described the DEADLINE
sched_yield()behaviour.So, for
SCHED_DEADLINEwe currently have this behaviour:/*
* Yield task semantic for -deadline tasks is:
** get off from the CPU until our next instance, with * a new runtime. This is of little use now, since we * don't have a bandwidth reclaiming mechanism. Anyway, * bandwidth reclaiming is planned for the future, and * yield_task_dl will indicate that some spare budget * is available for other task instances to use it.
Quoted 6 lines
*/
But, considering also the discussion above, I'm less sure now that's what we want. Still, I think we will want some way in the future to be able to say "I'm finished with my current job, give this remaining runtime to someone else", like another syscall or something.
Hi Juri, hi Peter,
my two cents:
A syscall to block the task until its next instance is definitely useful.
This way, a periodic task doesn't have to sleep anymore: the kernel takes care of unblocking the task at the right moment. This would be easier (for user-level) and more efficient too.
I don't know if using sched_yield() to get this behavior is a good choice or not. You have ways more experience than me :)
Best,
Claudio
Re: sched_{set,get}attr() manpage
In reply to Peter ZijlstraHi Peter,
Following the review comments that one or two people sent, are you planning to send in a revised version of this page? Also, is there any test code lying about somewhere that I could play with?
Thanks,
Michael
Quoted 137 lines · Peter Zijlstra
Quoted 3 lines · Henrik Austad
Quoted 1 line
The following "real-time" policies are also supported, for
why the "'s?
I borrowed those from
SCHED_SETSCHEDULER(2).Quoted 8 lines
Quoted 8 lines
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
...
Quoted 3 lines
Quoted 1 line
The flags argument should be 0.
What about
SCHED_FLAG_RESET_ON_FOR?Different flags. The one is
sched_attr::flagsthe other issched_setattr(.flags).Quoted 11 lines
Quoted 10 lines
The other
sched_attrfields are filled out as described insched_setattr().Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.Quoted 1 line
Isn't this last sentence redundant/sliglhtly repetitive?
I borrowed that from
SCHED_SETSCHEDULER(2)again.Quoted 7 lines
Quoted 7 lines
SCHED_DEADLINE: Sporadic task model deadline schedulingSCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.Quoted 8 lines
Quoted 4 lines
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EINVALwhen admission control tests fail.Perhaps add a note about the deadline-class having higher priority than the other classes; i.e. if a deadline-task is runnable, it will preempt any other
SCHED_(RR|FIFO)regardless of priority?Yes, good point, will do.
Quoted 23 lines
Quoted 23 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)Quoted 8 lines
Quoted 1 line
* A process calling
sched_yield(2)will be put at the end of the list.How about the recent discussion regarding
sched_yield(). Is this correct?lkml.kernel.org/r/alpine.DEB.2.02.1403312333100.14882-3cz04HxQyghMPrZFtrUIWQ@public.gmane.orgtronix.de
Is this the correct place to add a note explaining te potentional pitfalls using
sched_yield?I'm not sure; there's a
SCHED_YIELD(2)manpage to fill with that nonsense.Also; I realized I have not described the DEADLINE
sched_yield()behaviour.Quoted 18 lines
Quoted 7 lines
No other events will move a process scheduled under the
SCHED_FIFOpol‐ icy in the wait list of runnable processes with equal static priority.A
SCHED_FIFOprocess runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).Quoted 10 lines
SCHED_RR: Round Robin scheduling
SCHED_RRis a simple enhancement ofSCHED_FIFO. Everything described above forSCHED_FIFOalso applies toSCHED_RR, except that each process is only allowed to run for a maximum time quantum. If aSCHED_RRprocess has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. ASCHED_RRprocess that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved usingsched_rr_get_interval(2).Quoted 4 lines
-> Default is 0.1HZ ms
This is a question I get form time to time, having this in the manpage would be helpful.
Again, brazenly stolen from
SCHED_SETSCHEDULER(2); but yes. Also I'm not sure I'd call RR an enhancement of anything much at all ;-)Quoted 6 lines
Quoted 6 lines
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.EPERM The calling process does not have appropriate privileges.
Quoted 7 lines
Quoted 4 lines
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().Where's the EBUSY? It can throw this from
__sched_setscheduler()when it checks if there's enough bandwidth to run the task.Uhhm.. it got lost :-) /me quickly adds.
Signature · 7 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/ -- To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Following the review comments that one or two people sent, are you planning to send in a revised version of this page?
Yes, I just suck at getting around to it :-(, I'll do it first thing tomorrow.
Quoted 1 line
Also, is there any test code lying about somewhere that I could play with?
Juri?
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Steven Rostedt
maintainerRe: sched_{set,get}attr() manpage
Quoted 1 line · On Sun, 27 Apr 2014 21:34:49 +0200 Peter Zijlstra <[email protected]> wrote:
Quoted 1 line
Also, is there any test code lying about somewhere that I could play with?
I have a deadline program you can play with too:
http://rostedt.homelinux.com/private/deadline.c
-- Steve
Re: sched_{set,get}attr() manpage
In reply to Peter ZijlstraQuoted 6 lines · On Sun, 27 Apr 2014 21:34:49 +0200 Peter Zijlstra <[email protected]> wrote:
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Following the review comments that one or two people sent, are you planning to send in a revised version of this page?
Quoted 6 lines
Yes, I just suck at getting around to it :-(, I'll do it first thing tomorrow.
Quoted 1 line
Also, is there any test code lying about somewhere that I could play with?
Juri?
Yes. I use this two tools:
- rt-app (to create periodic workload, also not RT/DL)
https://github.com/gbagnoli/rt-app
- schedtool-dl (patched version of schetool)
https://github.com/jlelli/schedtool-dl
Both are aligned to the last interface.
Best,
- Juri
Peter Zijlstra
maintainersched_{set,get}attr() manpage
In reply to Michael Kerrisk (man-pages)Hi Michael,
find below an updated manpage, I did not apply the comments on parts that are identical to SCHED_SETSCHEDULER(2) in order to keep these texts in alignment. I feel that if we change one we should also change the other, and such a 'patch' is best done separate from the new manpage itself.
I did add the missing EBUSY error, and amended the text where it said we'd return EINVAL in that case.
I added a paragraph stating that SCHED_DEADLINE preempted anything else userspace can do (with the explicit mention of userspace to leave me wriggle room for the kernel's stop task :-).
I also did a short paragraph on the deadline sched_yield(). For further deadline yield details we should maybe add to the SCHED_YIELD(2) manpage.
Re juri/claudio; no I think sched_yield() as implemented for deadline makes sense, no other yield semantics other than NOP makes sense for it, and since we have the syscall already might as well make it do something useful.
---
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid. If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a first-in, first-out policy;
SCHED_RR a round-robin policy; and
SCHED_DEADLINE a deadline policy.
The semantics of each of these policies are detailed below.
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see NICE(2).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtime sched_attr::sched_deadline
sched_attr::sched_period should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters.
The flags argument should be 0.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The flags argument should be 0.
The other sched_attr fields are filled out as described in sched_setattr().
Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified by sched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.
For processes scheduled under one of the normal scheduling policies (SCHED_OTHER, SCHED_IDLE, SCHED_BATCH), sched_priority is not used in scheduling decisions (it must be specified as 0).
Processes scheduled under one of the real-time policies (SCHED_FIFO, SCHED_RR) have a sched_priority value in the range 1 (low) to 99 (high). (As the numbers imply, real-time processes always have higher priority than normal processes.) Note well: POSIX.1-2001 only requires an implementation to support a minimum 32 distinct priority levels for the real-time policies, and some systems supply just this minimum.
Portable programs should use sched_get_priority_min(2) and
sched_get_priority_max(2) to find the range of priorities supported for a particular policy.
Conceptually, the scheduler maintains a list of runnable processes for
each possible sched_priority value. In order to determine which
process runs next, the scheduler looks for the nonempty list with the highest static priority and selects the process at the head of this list.
A process's scheduling policy determines where it will be inserted into the list of processes with equal static priority and how it will move inside this list.
All scheduling is preemptive: if a process with a higher static prior‐ ity becomes ready to run, the currently running process will be pre‐ empted and returned to the wait list for its static priority level. The scheduling policy only determines the ordering within the list of runnable processes with equal static priority.
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of other SCHED_DEADLINE tasks.
SCHED_DEADLINE tasks will fail FORK(2) with -EAGAIN
Setting SCHED_DEADLINE can fail with -EBUSY when admission control tests fail.
Because of the nature of (G)EDF, SCHED_DEADLINE tasks are the highest priority (user controllable) tasks in the system, if any SCHED_DEADLINE task is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.
A SCHED_DEADLINE task calling sched_yield() will 'yield' the current job and wait for a new period to begin.
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFO can only be used with static priorities higher than 0, which means that when a SCHED_FIFO processes becomes runnable, it will always immediately preempt any currently running SCHED_OTHER, SCHED_BATCH, or SCHED_IDLE process. SCHED_FIFO is a simple scheduling algorithm with‐ out time slicing. For processes scheduled under the SCHED_FIFO policy, the following rules apply:
* A SCHED_FIFO process that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.
* When a SCHED_FIFO process becomes runnable, it will be inserted at the end of the list for its priority.
* A call to sched_setscheduler() or sched_setparam(2) will put the SCHED_FIFO (or SCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)
* A process calling sched_yield(2) will be put at the end of the list.
No other events will move a process scheduled under the SCHED_FIFO pol‐ icy in the wait list of runnable processes with equal static priority.
A SCHED_FIFO process runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).
SCHED_RR: Round Robin scheduling
SCHED_RR is a simple enhancement of SCHED_FIFO. Everything described above for SCHED_FIFO also applies to SCHED_RR, except that each process is only allowed to run for a maximum time quantum. If a SCHED_RR process has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. A SCHED_RR process that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved using sched_rr_get_interval(2).
SCHED_OTHER: Default Linux time-sharing scheduling
SCHED_OTHER can only be used at static priority 0. SCHED_OTHER is the standard Linux time-sharing scheduler that is intended for all pro‐ cesses that do not require the special real-time mechanisms. The process to run is chosen from the static priority 0 list based on a dynamic priority that is determined only inside this list. The dynamic priority is based on the nice value (set by nice(2) or setpriority(2)) and increased for each time quantum the process is ready to run, but denied to run by the scheduler. This ensures fair progress among all SCHED_OTHER processes.
SCHED_BATCH: Scheduling batch processes
(Since Linux 2.6.16.) SCHED_BATCH can only be used at static priority
0. This policy is similar to SCHED_OTHER in that it schedules the process according to its dynamic priority (based on the nice value). The difference is that this policy will cause the scheduler to always assume that the process is CPU-intensive. Consequently, the scheduler will apply a small scheduling penalty with respect to wakeup behaviour, so that this process is mildly disfavored in scheduling decisions.
This policy is useful for workloads that are noninteractive, but do not want to lower their nice value, and for workloads that want a determin‐ istic scheduling policy without interactivity causing extra preemptions (between the workload's tasks).
SCHED_IDLE: Scheduling very low priority jobs
(Since Linux 2.6.23.) SCHED_IDLE can only be used at static priority 0; the process nice value has no influence for this policy.
This policy is intended for running jobs at extremely low priority (lower even than a +19 nice value with the SCHED_OTHER or SCHED_BATCH policies).
RETURN VALUE
On success, sched_setattr() and sched_getattr() return 0. On error, -1 is returned, and errno is set appropriately.
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct sched_attr is either too
big, see sched_setattr(), or too small, see sched_getattr().
EBUSY SCHED_DEADLINE admission control failure
NOTES
While the text above (and in SCHED_SETSCHEDULER(2)) talks about processes, in actual fact these system calls are thread specific.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: sched_{set,get}attr() manpage
Hi Peter,
Quoted 15 lines · Peter Zijlstra
Hi Michael,
find below an updated manpage, I did not apply the comments on parts that are identical to
SCHED_SETSCHEDULER(2)in order to keep these texts in alignment. I feel that if we change one we should also change the other, and such a 'patch' is best done separate from the new manpage itself.I did add the missing EBUSY error, and amended the text where it said we'd return EINVAL in that case.
I added a paragraph stating that
SCHED_DEADLINEpreempted anything else userspace can do (with the explicit mention of userspace to leave me wriggle room for the kernel's stop task :-).
Quoted 8 lines
I also did a short paragraph on the deadline
sched_yield(). For further deadline yield details we should maybe add to theSCHED_YIELD(2)manpage.Re juri/claudio; no I think
sched_yield()as implemented for deadline makes sense, no other yield semantics other than NOP makes sense for it, and since we have the syscall already might as well make it do something useful.
Thanks for the updated page. Would you be willing
to revise as per the comments below.
Quoted 24 lines
NAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);
Quoted 4 lines
DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
Around about here, I think there needs to be a sentence explaining that sched_setattr() provides a superset of the functionality of sched_setscheduler(2) and setpritority(2). I mean, it can do all that those two calls can do, right?
Quoted 17 lines
If pid equals zero, the scheduling policy and attributes
of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
Quoted 7 lines
SCHED_FIFOa first-in, first-out policy;
SCHED_RRa round-robin policy; and
SCHED_DEADLINEa deadline policy.The semantics of each of these policies are detailed below.
The semantics of each of these policies are detailed in sched(7).
[See my comments below]
Quoted 22 lines
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see NICE(2).
Quoted 7 lines
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtimesched_attr::sched_deadline
sched_attr::sched_periodshould only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters.
Could you add (a lot ;-)) more detail on these three fields? Assume the reader does not know about this traditional sporadic task model, and then give some explanation of what these three fields do. Probably, at this point you can work in some statement about the admission control test.
[but, see my comment below. It may be that sched(7) is a better place for this detail.
Quoted 14 lines
The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.
Quoted 4 lines
The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().
I assume that everything between my [[[ and ]]] blocks below is taken straight from sched_setscheduler(2). (If that is not true, please let me know.) This reminds me that there is a structural fault in this part of man-pages ;-). The problem is sched_setscheduler(2) currently tries to do two things:
[a] Document the sched_setscheduler() and sched_scheduler system calls
[b] Provide and overview od scheduling policies and parameters.
It should really only do the former. I have now gone through the task of separating [b] out into a separate page, sched(7), which other pages, such as sched_setscheduler(2) and sched_setattr(2) can refer to. You can see the current versions of sched_setscheduelr.2 and sched.7 in Git
(https://www.kernel.org/doc/man-pages/download.html )
So, what I would ideally like to see
[1] A page describing the sched_setattr() and sched_getattr() APIs
[2] A piece of text describing the SCHED_DEADLINE policy, which I can drop into sched(7).
Could you revise like that?
[[[[
Quoted 32 lines
Scheduling Policies
The scheduler is the kernel component that decides which runnable process will be executed by the CPU next. Each process has an associ‐ ated scheduling policy and a static scheduling priority, sched_prior‐ ity; these are the settings that are modified bysched_setscheduler(). The scheduler makes it decisions based on knowledge of the scheduling policy and static priority of all processes on the system.For processes scheduled under one of the normal scheduling policies (
SCHED_OTHER,SCHED_IDLE,SCHED_BATCH),sched_priorityis not used in scheduling decisions (it must be specified as 0).Processes scheduled under one of the real-time policies (
SCHED_FIFO,SCHED_RR) have asched_priorityvalue in the range 1 (low) to 99 (high). (As the numbers imply, real-time processes always have higher priority than normal processes.) Note well: POSIX.1-2001 only requires an implementation to support a minimum 32 distinct priority levels for the real-time policies, and some systems supply just this minimum.
Portable programs should usesched_get_priority_min(2)and
sched_get_priority_max(2)to find the range of priorities supported for a particular policy.Conceptually, the scheduler maintains a list of runnable processes for
each possiblesched_priorityvalue. In order to determine which
process runs next, the scheduler looks for the nonempty list with the highest static priority and selects the process at the head of this list.A process's scheduling policy determines where it will be inserted into the list of processes with equal static priority and how it will move inside this list.
Quoted 5 lines
All scheduling is preemptive: if a process with a higher static prior‐ ity becomes ready to run, the currently running process will be pre‐ empted and returned to the wait list for its static priority level. The scheduling policy only determines the ordering within the list of runnable processes with equal static priority.
]]]]
Quoted 12 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EBUSYwhen admission control tests fail.
Quoted 7 lines
Because of the nature of (G)EDF,
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.
This is the piece that could go into sched(7), but I'd like it to include a discussion of deadline, period, and runtime.
[[[[
Quoted 68 lines
SCHED_FIFO: First In-First Out scheduling
SCHED_FIFOcan only be used with static priorities higher than 0, which means that when aSCHED_FIFOprocesses becomes runnable, it will always immediately preempt any currently runningSCHED_OTHER,SCHED_BATCH, orSCHED_IDLEprocess.SCHED_FIFOis a simple scheduling algorithm with‐ out time slicing. For processes scheduled under theSCHED_FIFOpolicy, the following rules apply:* A
SCHED_FIFOprocess that has been preempted by another process of higher priority will stay at the head of the list for its priority and will resume execution as soon as all processes of higher prior‐ ity are blocked again.* When a
SCHED_FIFOprocess becomes runnable, it will be inserted at the end of the list for its priority.* A call to
sched_setscheduler()orsched_setparam(2)will put theSCHED_FIFO(orSCHED_RR) process identified by pid at the start of the list if it was runnable. As a consequence, it may preempt the
currently running process if it has the same priority.
(POSIX.1-2001 specifies that the process should go to the end of the list.)* A process calling
sched_yield(2)will be put at the end of the list.No other events will move a process scheduled under the
SCHED_FIFOpol‐ icy in the wait list of runnable processes with equal static priority.A
SCHED_FIFOprocess runs until either it is blocked by an I/O request,
it is preempted by a higher priority process, or it calls
sched_yield(2).
SCHED_RR: Round Robin scheduling
SCHED_RRis a simple enhancement ofSCHED_FIFO. Everything described above forSCHED_FIFOalso applies toSCHED_RR, except that each process is only allowed to run for a maximum time quantum. If aSCHED_RRprocess has been running for a time period equal to or longer than the time quantum, it will be put at the end of the list for its priority. ASCHED_RRprocess that has been preempted by a higher priority process and subsequently resumes execution as a running process will complete the unexpired portion of its round robin time quantum. The length of the time quantum can be retrieved usingsched_rr_get_interval(2).
SCHED_OTHER: Default Linux time-sharing scheduling
SCHED_OTHERcan only be used at static priority 0.SCHED_OTHERis the standard Linux time-sharing scheduler that is intended for all pro‐ cesses that do not require the special real-time mechanisms. The process to run is chosen from the static priority 0 list based on a dynamic priority that is determined only inside this list. The dynamic priority is based on the nice value (set by nice(2) or setpriority(2)) and increased for each time quantum the process is ready to run, but denied to run by the scheduler. This ensures fair progress among allSCHED_OTHERprocesses.
SCHED_BATCH: Scheduling batch processes
(Since Linux 2.6.16.)SCHED_BATCHcan only be used at static priority
0. This policy is similar toSCHED_OTHERin that it schedules the process according to its dynamic priority (based on the nice value). The difference is that this policy will cause the scheduler to always assume that the process is CPU-intensive. Consequently, the scheduler will apply a small scheduling penalty with respect to wakeup behaviour, so that this process is mildly disfavored in scheduling decisions.This policy is useful for workloads that are noninteractive, but do not want to lower their nice value, and for workloads that want a determin‐ istic scheduling policy without interactivity causing extra preemptions (between the workload's tasks).
Quoted 7 lines
SCHED_IDLE: Scheduling very low priority jobs
(Since Linux 2.6.23.)SCHED_IDLEcan only be used at static priority 0; the process nice value has no influence for this policy.This policy is intended for running jobs at extremely low priority (lower even than a +19 nice value with the
SCHED_OTHERorSCHED_BATCHpolicies).
]]]]
Quoted 8 lines
RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.
Quoted 8 lines
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failure
The above is the only place on the page that mentions admission control. As well as the suggestions above, it would be nice to have somewhere a summary of how admission control is calculated.
Quoted 4 lines
NOTES
While the text above (and inSCHED_SETSCHEDULER(2)) talks about processes, in actual fact these system calls are thread specific.
Cheers,
Michael
Signature · 7 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/ -- To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 22 lines · Michael Kerrisk (man-pages)
Hi Peter,
Quoted 19 lines · Peter Zijlstra
Hi Michael,
find below an updated manpage, I did not apply the comments on parts that are identical to
SCHED_SETSCHEDULER(2)in order to keep these texts in alignment. I feel that if we change one we should also change the other, and such a 'patch' is best done separate from the new manpage itself.I did add the missing EBUSY error, and amended the text where it said we'd return EINVAL in that case.
I added a paragraph stating that
SCHED_DEADLINEpreempted anything else userspace can do (with the explicit mention of userspace to leave me wriggle room for the kernel's stop task :-).I also did a short paragraph on the deadline
sched_yield(). For further deadline yield details we should maybe add to theSCHED_YIELD(2)manpage.
Quoted 7 lines
Quoted 4 lines
Re juri/claudio; no I think
sched_yield()as implemented for deadline makes sense, no other yield semantics other than NOP makes sense for it, and since we have the syscall already might as well make it do something useful.Thanks for the updated page. Would you be willing
to revise as per the comments below.
Ok.
Quoted 30 lines
Quoted 25 lines
NAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);Quoted 4 lines
DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
Quoted 4 lines
Around about here, I think there needs to be a sentence explaining that
sched_setattr()provides a superset of the functionality ofsched_setscheduler(2)and setpritority(2). I mean, it can do all that those two calls can do, right?
Almost; setpriority() has the .which argument which we don't have. So while that syscall can change the nice value for an entire process group or user, sched_setattr() can only change the nice value for 1 task.
But yes, I can mention something along those lines.
Quoted 19 lines
Quoted 19 lines
If pid equals zero, the scheduling policy and attributes
of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa first-in, first-out policy;
Quoted 7 lines
Quoted 5 lines
SCHED_RRa round-robin policy; and
SCHED_DEADLINEa deadline policy.The semantics of each of these policies are detailed below.
The semantics of each of these policies are detailed in sched(7).
I don't appear to have SCHED(7), how new is that?
Quoted 32 lines
[See my comments below]
Quoted 22 lines
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see NICE(2).Quoted 7 lines
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99].
sched_attr::sched_runtimesched_attr::sched_deadline
sched_attr::sched_periodshould only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters.
Quoted 8 lines
Could you add (a lot ;-)) more detail on these three fields? Assume the reader does not know about this traditional sporadic task model, and then give some explanation of what these three fields do. Probably, at this point you can work in some statement about the admission control test.
[but, see my comment below. It may be that sched(7) is a better place for this detail.
Yes, I think SCHED(7) would be a better place; also I think I forgot to put a reference in to Documentation/scheduler/sched-deadline.txt
I'll try and write something concise. This is the stuff of books, not paragraphs :/
Quoted 14 lines
Quoted 14 lines
The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid. If pid equals zero, the policy of the calling process will be retrieved.The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.
Quoted 7 lines
Quoted 4 lines
The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().I assume that everything between my [[[ and ]]] blocks below is taken straight from
sched_setscheduler(2). (If that is not true, please let me know.)
That did indeed look about right.
Quoted 12 lines
This reminds me that there is a structural fault in this part of man-pages ;-). The problem is
sched_setscheduler(2)currently tries to do two things:[a] Document the
sched_setscheduler()andsched_schedulersystem calls
[b] Provide and overview od scheduling policies and parameters.It should really only do the former. I have now gone through the task of separating [b] out into a separate page, sched(7), which other pages, such as
sched_setscheduler(2)andsched_setattr(2)can refer to. You can see the current versions of sched_setscheduelr.2 and sched.7 in Git
(https://www.kernel.org/doc/man-pages/download.html )
Quoted 7 lines
So, what I would ideally like to see
[1] A page describing the
sched_setattr()andsched_getattr()APIs
[2] A piece of text describing theSCHED_DEADLINEpolicy, which I can drop into sched(7).Could you revise like that?
ACK.
Quoted 43 lines
[[[[
]]]]
Quoted 12 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server). The CBS guarantees that tasks that over-run their specified budget are throttled and do not affect the correct performance of otherSCHED_DEADLINEtasks.
SCHED_DEADLINEtasks will fail FORK(2) with-EAGAINSetting
SCHED_DEADLINEcan fail with-EBUSYwhen admission control tests fail.Quoted 7 lines
Because of the nature of (G)EDF,
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.This is the piece that could go into sched(7), but I'd like it to include a discussion of deadline, period, and runtime.
[[[[
]]]]
Quoted 12 lines
RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the policy.EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
Quoted 8 lines
Quoted 4 lines
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failureThe above is the only place on the page that mentions admission control. As well as the suggestions above, it would be nice to have somewhere a summary of how admission control is calculated.
I think I'll write down what admission control is without specifics. Giving specifics pins you down on the implementation. In general admission control enforces a bound on the schedulability of the task set. New and interesting ways of computing schedulability are the subject of papers each year.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
In reply to Michael Kerrisk (man-pages)On Tue, Apr 29, 2014 at 03:08:55PM +0200, Michael Kerrisk (man-pages) wrote:
Juri, Dario, Can you have a look at the 2nd part; I'm not at all sure I got the activate/release the right way around.
My current thinking was that we activate first, and then release it to go run. But googling the terms only confused me more. I suppose its one of those things that's not actually _that_ well defined. And I hope the ASCII art actually clarifies things better than the terms used.
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIs
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr() replaces sched_setscheduler(), sched_setparam(), nice() and some of setpriority().
If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a static priority first-in, first-out policy;
SCHED_RR a static priority round-robin policy; and
SCHED_DEADLINE a dynamic priority deadline policy.
The semantics of each of these policies are detailed in sched(7).
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtime sched_attr::sched_deadline
sched_attr::sched_period should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters, see sched(7).
The flags argument should be 0.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid.
Similar to sched_setattr(), sched_getattr() replaces sched_getscheduler(), sched_getparam() and some of getpriority().
If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The flags argument should be 0.
The other sched_attr fields are filled out as described in sched_setattr().
RETURN VALUE
On success, sched_setattr() and sched_getattr() return 0. On error, -1 is returned, and errno is set appropriately.
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct sched_attr is either too
big, see sched_setattr(), or too small, see sched_getattr().
EBUSY SCHED_DEADLINE admission control failure, see sched(7).
NOTES
While the text above (and in sched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.
Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).
A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [us]. Each job will have an absolute deadline relative to its activation before which it must finish its execution, and it shall at no time run longer than runtime [us] after its release.
activation/wakeup absolute deadline
| release |
v v v
-------x--------x--------------x--------x-------
|<- Runtime -->|
|<---------- Deadline ->| |<---------- Period ----------->|
This gives: runtime <= (rel) deadline <= period.
The CBS guarantees that tasks that over-run their specified runtime are throttled and do not affect the correct performance of other SCHED_DEADLINE tasks.
In general a task set of such tasks it not feasible/schedulable within the given constraints. Therefore we must do an admittance test on setting/changing SCHED_DEADLINE policy/attributes.
This admission test calculates that the task set is feasible/schedulable, failing this, sched_setattr() will return -EBUSY.
For example, it is required (but not sufficient) for the total utilization to be less or equal to the total amount of cpu time available. That is, since each job can maximally run for runtime [us] per period [us], that task's utilization is runtime/period. Summing this over all tasks must be less than the total amount of CPUs present.
SCHED_DEADLINE tasks will fail fork(2) with -EAGAIN.
Because of the nature of (G)EDF, SCHED_DEADLINE tasks are the highest priority (user controllable) tasks in the system, if any SCHED_DEADLINE task is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.
A SCHED_DEADLINE task calling sched_yield() will 'yield' the current job and wait for a new period to begin.
Re: sched_{set,get}attr() manpage
Hi Peter,
Thanks for the revision. More comments below. Could you revise in the light of those comments, and hopefully also after feedback from Juri and Dario?
Quoted 94 lines · Peter Zijlstra
On Tue, Apr 29, 2014 at 03:08:55PM +0200, Michael Kerrisk (man-pages) wrote:
Juri, Dario, Can you have a look at the 2nd part; I'm not at all sure I got the activate/release the right way around.
My current thinking was that we activate first, and then release it to go run. But googling the terms only confused me more. I suppose its one of those things that's not actually _that_ well defined. And I hope the ASCII art actually clarifies things better than the terms used.
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIsNAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr()replacessched_setscheduler(),sched_setparam(),nice()and some ofsetpriority().If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa static priority first-in, first-out policy;
SCHED_RRa static priority round-robin policy; and
SCHED_DEADLINEa dynamic priority deadline policy.The semantics of each of these policies are detailed in sched(7).
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see sched(7).
Quoted 8 lines
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtimesched_attr::sched_deadline
sched_attr::sched_periodshould only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters, see sched(7).
So, are there fields expressed in some unit (presumably microseconds)? Best to mention that here.
Quoted 68 lines
The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid.Similar to
sched_setattr(),sched_getattr()replacessched_getscheduler(),sched_getparam()and some ofgetpriority().If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failure, see sched(7).NOTES
While the text above (and insched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [us]. Each job will have an absolute deadline relative to its activation before which it must finish its execution, and it shall at no time run longer than runtime [us] after its release.
activation/wakeup absolute deadline
| release |
v v v
-------x--------x--------------x--------x-------
|<- Runtime -->|
|<---------- Deadline ->| |<---------- Period ----------->|
Quoted 1 line
This gives: runtime <= (rel) deadline <= period.
So, the 'sched_deadline' field in the 'sched_attr' expresses the release deadline? (I had initially thought it was the "absolute deadline". Could you make this clearer in the text please.
Quoted 5 lines
The CBS guarantees that tasks that over-run their specified runtime are throttled and do not affect the correct performance of other
SCHED_DEADLINEtasks.In general a task set of such tasks it not feasible/schedulable
That last line is garbled. Could you fix, please.
Also, could you add some words to explain what you mean by 'task set'.
Quoted 7 lines
within the given constraints. Therefore we must do an admittance test on setting/changing
SCHED_DEADLINEpolicy/attributes.This admission test calculates that the task set is feasible/schedulable, failing this,
sched_setattr()will return-EBUSY.
Quoted 8 lines
For example, it is required (but not sufficient) for the total utilization to be less or equal to the total amount of cpu time available. That is, since each job can maximally run for runtime [us] per period [us], that task's utilization is runtime/period. Summing this over all tasks must be less than the total amount of CPUs present.
SCHED_DEADLINEtasks will fail fork(2) with-EAGAIN.
Except if SCHED_RESET_ON_FORK was set, right? If yes, that should be mentioned here.
Quoted 7 lines
Because of the nature of (G)EDF,
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.
So, I'm trying to naively understand how this all works. If different processes specify different deadline periods, how does the kernel deal with that? Is it worth adding some detail on this point?
Thanks,
Michael
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 7 lines · Michael Kerrisk (man-pages)
Hi Peter,
Thanks for the revision. More comments below. Could you revise in the light of those comments, and hopefully also after feedback from Juri and Dario?
Quoted 1 line
Quoted 8 lines
Quoted 5 lines
sched_attr::sched_runtimesched_attr::sched_deadline
sched_attr::sched_periodshould only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters, see sched(7).So, are there fields expressed in some unit (presumably microseconds)? Best to mention that here.
Oh wait, no its nanoseconds. Which means I should amend the text below.
Quoted 10 lines
Quoted 10 lines
Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis an implementation of GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [us]. Each job will have an absolute deadline relative to its activation before which it must
(A)
Quoted 11 lines
Quoted 11 lines
finish its execution, and it shall at no time run longer than runtime [us] after its release.
activation/wakeup absolute deadline
| release |
v v v
-------x--------x--------------x--------x-------
|<- Runtime -->|
|<---------- Deadline ->| |<---------- Period ----------->|
Quoted 5 lines
Quoted 1 line
This gives: runtime <= (rel) deadline <= period.
So, the '
sched_deadline' field in the 'sched_attr' expresses the release deadline? (I had initially thought it was the "absolute deadline". Could you make this clearer in the text please.
No, and yes, sched_attr::sched_deadline is a relative deadline wrt to the activation. Like said at (A).
So we get: absolute deadline = activation + relative deadline.
And we must be done running at that point, so the very last possible release moment is: absolute deadline - runtime.
And therefore, it too is a release deadline, since we must not release later than that.
Quoted 7 lines
Quoted 5 lines
The CBS guarantees that tasks that over-run their specified runtime are throttled and do not affect the correct performance of other
SCHED_DEADLINEtasks.In general a task set of such tasks it not feasible/schedulable
That last line is garbled. Could you fix, please.
s/it/is/
Quoted 1 line
Also, could you add some words to explain what you mean by 'task set'.
A set of tasks? :-) In particular all tasks in the system of SCHED_DEADLINE, indicated by 'of such'.
Quoted 14 lines
Quoted 14 lines
within the given constraints. Therefore we must do an admittance test on setting/changing
SCHED_DEADLINEpolicy/attributes.This admission test calculates that the task set is feasible/schedulable, failing this,
sched_setattr()will return-EBUSY.For example, it is required (but not sufficient) for the total utilization to be less or equal to the total amount of cpu time available. That is, since each job can maximally run for runtime [us] per period [us], that task's utilization is runtime/period. Summing this over all tasks must be less than the total amount of CPUs present.
Quoted 4 lines
Quoted 1 line
SCHED_DEADLINEtasks will fail fork(2) with-EAGAIN.Except if
SCHED_RESET_ON_FORKwas set, right? If yes, that should be mentioned here.
Ah, indeed.
Quoted 11 lines
Quoted 7 lines
Because of the nature of (G)EDF,
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt anything FIFO/RR/OTHER/BATCH/IDLE task out there.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.So, I'm trying to naively understand how this all works. If different processes specify different deadline periods, how does the kernel deal with that? Is it worth adding some detail on this point?
Userspace should not rely on any implementation details there. Saying its a (G)EDF scheduler is maybe already too much. All userspace should really care about is that its tasks _should_ be scheduled such that it meets the specified requirements.
There are multiple scheduling algorithms that can be employed to make it so, and I don't want to pin us to whatever we chose to implement this time.
That said, the current (G)EDF is a soft realtime scheduler in that it guarantees a bounded tardiness (which is the time we can miss the deadline by) but not a hard realtime, since the bound is not 0.
Anyway, for your elucidation; assuming no overhead and a UP system (SMP is a right head-ache), and a further assumption that deadline == period. It is reasonable straight forward to see that scheduling the task with the earliest deadline will satisfy the constraints IFF the total utilization (\Sum runtime_i / deadline_i) <= 1.
Suppose two tasks: A := { 5, 10 } and B := { 10, 20 } with strict periodic activation:
A1,B1 A2 Ad2
| Ad1 Bd1
v v v --AAAAABBBBBAAAAABBBBBx--
--AAAAABBBBBBBBBBAAAAAx--
Where A# is the #th activation, Ad# is the corresponding #th deadline before which we must have sufficient time.
Since we're perfectly synced up there is a tie and we get two possible outcomes. But note that in either case A has gotten 2x its 5 As and B has gotten its 10 Bs.
Non-periodic activation, and deadline != period make the thing more interesting, but at that point I would ask Juri (or others) to refer you to a paper/book.
Now, let me go update the texts yet again :-)
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
In reply to Michael Kerrisk (man-pages)Quoted 5 lines · Michael Kerrisk (man-pages)
Hi Peter,
Thanks for the revision. More comments below. Could you revise in the light of those comments, and hopefully also after feedback from Juri and Dario?
New text below; hopefully a little clearer. If not, do holler.
---
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIs
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr() replaces sched_setscheduler(), sched_setparam(), nice() and some of setpriority().
If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a static priority first-in, first-out policy;
SCHED_RR a static priority round-robin policy; and
SCHED_DEADLINE a dynamic priority deadline policy.
The semantics of each of these policies are detailed in sched(7).
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtime in nanoseconds, sched_attr::sched_deadline in nanoseconds, sched_attr::sched_period in nanoseconds, should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters, see sched(7).
The flags argument should be 0.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid.
Similar to sched_setattr(), sched_getattr() replaces sched_getscheduler(), sched_getparam() and some of getpriority().
If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The flags argument should be 0.
The other sched_attr fields are filled out as described in sched_setattr().
RETURN VALUE
On success, sched_setattr() and sched_getattr() return 0. On error, -1 is returned, and errno is set appropriately.
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct sched_attr is either too
big, see sched_setattr(), or too small, see sched_getattr().
EBUSY SCHED_DEADLINE admission control failure, see sched(7).
NOTES
While the text above (and in sched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.
While the SCHED_DEADLINE parameters are in nanoseconds, current kernels truncate the lower 10 bits and we get an effective microsecond resolution.
Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is currently implemented using GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).
A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [ns]. Each job will have an absolute deadline relative to its activation before which it must finish its execution, and it shall at no time run longer than runtime [ns] after its release.
activation/wakeup absolute deadline
| release |
v v v
-------x--------x--------------x--------x-------
|<- Runtime -->|
|<---------- Deadline ->| |<---------- Period ----------->|
This gives: runtime <= (rel) deadline <= period.
The CBS guarantees non-interference between tasks, by throttling tasks that attempt to over-run their specified runtime.
In general the set of all SCHED_DEADLINE tasks is not feasible/schedulable within the given constraints. Therefore we must do an admittance test on setting/changing SCHED_DEADLINE policy/attributes.
This admission test calculates that the task set is feasible/schedulable, failing this, sched_setattr() will return -EBUSY.
For example, it is required (but not necessarily sufficient) for the total utilization to be less or equal to the total amount of CPUs available, where, since each task can maximally run for runtime [us] per period [us], that task's utilization is its runtime/period.
Because we must be able to calculate admittance SCHED_DEADLINE tasks are the highest priority (user controllable) tasks in the system, if any SCHED_DEADLINE task is runnable it will preempt any FIFO/RR/OTHER/BATCH/IDLE task.
SCHED_DEADLINE tasks will fail fork(2) with -EAGAIN, except when the forking task has SCHED_FLAG_RESET_ON_FORK set.
A SCHED_DEADLINE task calling sched_yield() will 'yield' the current job and wait for a new period to begin.
--
To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: sched_{set,get}attr() manpage
Hi,
sorry for the late reply, but I was travelling for work.
Quoted 146 lines · On Wed, 30 Apr 2014 15:09:37 +0200 Peter Zijlstra <[email protected]> wrote:
Quoted 5 lines · Michael Kerrisk (man-pages)
Hi Peter,
Thanks for the revision. More comments below. Could you revise in the light of those comments, and hopefully also after feedback from Juri and Dario?
New text below; hopefully a little clearer. If not, do holler.
---
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIsNAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr()replacessched_setscheduler(),sched_setparam(),nice()and some ofsetpriority().If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa static priority first-in, first-out policy;
SCHED_RRa static priority round-robin policy; and
SCHED_DEADLINEa dynamic priority deadline policy.The semantics of each of these policies are detailed in sched(7).
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtimein nanoseconds,sched_attr::sched_deadlinein nanoseconds,sched_attr::sched_periodin nanoseconds, should only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters, see sched(7).The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid.Similar to
sched_setattr(),sched_getattr()replacessched_getscheduler(),sched_getparam()and some ofgetpriority().If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failure, see sched(7).
Quoted 11 lines
NOTES
While the text above (and insched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.While the
SCHED_DEADLINEparameters are in nanoseconds, current kernels truncate the lower 10 bits and we get an effective microsecond resolution.Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
I'd tweak the following a bit, just to be sure that users understand that one thing is the model of tasks behavior and another thing is what you can set using SCHED_DEADLINE. Then the two things are obviously closely related, but different settings can be in principle used to schedule the same task set (with lot of literature about optimal settings and so on).
Quoted 11 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis currently implemented using GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [ns]. Each job will have an absolute deadline relative to its activation before which it must finish its execution, and it shall at no time run longer than runtime [ns] after its release.
A sporadic task is one that has a sequence of jobs, where each job is activated at most once per period. Each job has also a relative deadline, before which it should finish execution, and a computation time, that is the time necessary for executing the job without interruption. The instant of time when a task wakes up, because a new job has to be executed, is called arrival time (and it is also referred to as request time or release time). Start time is instead the time at which a task starts its execution. The absolute deadline is thus obtained adding the relative deadline to the arrival time. The following diagram clarifies these terms:
Quoted 8 lines
activation/wakeup absolute deadline
| release |
v v v
-------x--------x--------------x--------x-------
|<- Runtime -->|
|<---------- Deadline ->|
|<---------- Period ----------->| arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- comp. ->|
|<---------- rel. deadline ->|
|<---------- period --------------->|SCHED_DEADLINE allows the user to specify three parameters (see sched_setattr(2)): Runtime [ns], Deadline [ns] and Period [ns]. Such parameters has not necessarily to correspond to the aforementioned terms, while usual practise is to set Runtime to something bigger than the average computation time (or worst-case execution time for hard real-time tasks), Deadline to the relative deadline and Period to the period of the task. With such a setting we would have:
arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- Runtime ->|
|<---------- Deadline ------>|
|<---------- Period --------------->|Quoted 2 lines
This gives: runtime <= (rel) deadline <= period.
It is checked that: Runtime <= Deadline <= Period.
Quoted 3 lines
The CBS guarantees non-interference between tasks, by throttling tasks that attempt to over-run their specified runtime.
s/runtime/Runtime to be consistent.
Quoted 5 lines
In general the set of all
SCHED_DEADLINEtasks is not feasible/schedulable within the given constraints. Therefore we must do an admittance test on setting/changingSCHED_DEADLINEpolicy/attributes.
To guarantee some degree of timeliness we must do an admission test on setting/changing SCHED_DEADLINE policy/attributes.
Quoted 10 lines
This admission test calculates that the task set is feasible/schedulable, failing this,
sched_setattr()will return-EBUSY.For example, it is required (but not necessarily sufficient) for the total utilization to be less or equal to the total amount of CPUs available, where, since each task can maximally run for runtime [us] per period [us], that task's utilization is its runtime/period.
CPUs available, where, since each task can maximally run for Runtime per Period, that task's utilization is its Runtime/Period.
Quoted 11 lines
Because we must be able to calculate admittance
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt any FIFO/RR/OTHER/BATCH/IDLE task.
SCHED_DEADLINEtasks will fail fork(2) with-EAGAIN, except when the forking task hasSCHED_FLAG_RESET_ON_FORKset.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.
Does it look any better?
Thanks,
- Juri
Re: sched_{set,get}attr() manpage
Hi Peter,
Looks like a good set of comments from Juri. Could you revise and resubmit?
By the way, I assume you are just writing this page as raw text. While I'd prefer to get proper man markup source, I'll add that if you if you don't :-/. But, in that case, I need to know the copyright and license you want to use. Please see
https://www.kernel.org/doc/man-pages/licenses.html
Cheers,
Michael
Quoted 283 lines · Juri Lelli
Hi,
sorry for the late reply, but I was travelling for work.
Quoted 146 lines · On Wed, 30 Apr 2014 15:09:37 +0200 Peter Zijlstra…
Quoted 5 lines · Michael Kerrisk (man-pages)
Hi Peter,
Thanks for the revision. More comments below. Could you revise in the light of those comments, and hopefully also after feedback from Juri and Dario?
New text below; hopefully a little clearer. If not, do holler.
---
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIsNAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr()replacessched_setscheduler(),sched_setparam(),nice()and some ofsetpriority().If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa static priority first-in, first-out policy;
SCHED_RRa static priority round-robin policy; and
SCHED_DEADLINEa dynamic priority deadline policy.The semantics of each of these policies are detailed in sched(7).
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtimein nanoseconds,sched_attr::sched_deadlinein nanoseconds,sched_attr::sched_periodin nanoseconds, should only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters, see sched(7).The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid.Similar to
sched_setattr(),sched_getattr()replacessched_getscheduler(),sched_getparam()and some ofgetpriority().If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failure, see sched(7).Quoted 11 lines
NOTES
While the text above (and insched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.While the
SCHED_DEADLINEparameters are in nanoseconds, current kernels truncate the lower 10 bits and we get an effective microsecond resolution.Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).I'd tweak the following a bit, just to be sure that users understand that one thing is the model of tasks behavior and another thing is what you can set using
SCHED_DEADLINE. Then the two things are obviously closely related, but different settings can be in principle used to schedule the same task set (with lot of literature about optimal settings and so on).Quoted 11 lines
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis currently implemented using GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).A sporadic task is on that has a sequence of jobs, where each job is activated at most once per period [ns]. Each job will have an absolute deadline relative to its activation before which it must finish its execution, and it shall at no time run longer than runtime [ns] after its release.
A sporadic task is one that has a sequence of jobs, where each job is activated at most once per period. Each job has also a relative deadline, before which it should finish execution, and a computation time, that is the time necessary for executing the job without interruption. The instant of time when a task wakes up, because a new job has to be executed, is called arrival time (and it is also referred to as request time or release time). Start time is instead the time at which a task starts its execution. The absolute deadline is thus obtained adding the relative deadline to the arrival time. The following diagram clarifies these terms:
Quoted 8 lines
activation/wakeup absolute deadline | release | v v v -------x--------x--------------x--------x------- |<- Runtime -->| |<---------- Deadline ->| |<---------- Period ----------->|arrival/wakeup absolute deadline | start time | v v v -------x--------xoooooooooooo-------x--------x----- |<- comp. ->| |<---------- rel. deadline ->| |<---------- period --------------->|
SCHED_DEADLINEallows the user to specify three parameters (seesched_setattr(2)): Runtime [ns], Deadline [ns] and Period [ns]. Such parameters has not necessarily to correspond to the aforementioned terms, while usual practise is to set Runtime to something bigger than the average computation time (or worst-case execution time for hard real-time tasks), Deadline to the relative deadline and Period to the period of the task. With such a setting we would have:arrival/wakeup absolute deadline | start time | v v v -------x--------xoooooooooooo-------x--------x----- |<- Runtime ->| |<---------- Deadline ------>| |<---------- Period --------------->|Quoted 2 lines
This gives: runtime <= (rel) deadline <= period.
It is checked that: Runtime <= Deadline <= Period.
Quoted 3 lines
The CBS guarantees non-interference between tasks, by throttling tasks that attempt to over-run their specified runtime.
s/runtime/Runtime to be consistent.
Quoted 5 lines
In general the set of all
SCHED_DEADLINEtasks is not feasible/schedulable within the given constraints. Therefore we must do an admittance test on setting/changingSCHED_DEADLINEpolicy/attributes.To guarantee some degree of timeliness we must do an admission test on setting/changing
SCHED_DEADLINEpolicy/attributes.Quoted 10 lines
This admission test calculates that the task set is feasible/schedulable, failing this,
sched_setattr()will return-EBUSY.For example, it is required (but not necessarily sufficient) for the total utilization to be less or equal to the total amount of CPUs available, where, since each task can maximally run for runtime [us] per period [us], that task's utilization is its runtime/period.
CPUs available, where, since each task can maximally run for Runtime per Period, that task's utilization is its Runtime/Period.
Quoted 11 lines
Because we must be able to calculate admittance
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt any FIFO/RR/OTHER/BATCH/IDLE task.
SCHED_DEADLINEtasks will fail fork(2) with-EAGAIN, except when the forking task hasSCHED_FLAG_RESET_ON_FORKset.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.Does it look any better?
Thanks,
- Juri
Signature · 7 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/ -- To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Looks like a good set of comments from Juri. Could you revise and resubmit?
Yeah, I'll try and get it done today, but there's a few icky bugs waiting for my attention as well, I'll do me bestest :-)
Quoted 3 lines
By the way, I assume you are just writing this page as raw text. While I'd prefer to get proper man markup source, I'll add that if you if you don't :-/.
Well, learning *roff will likely take me more time than writing this text + all revisions so far :/ But yeah, I appreciate the grief.
Is there a TeX variant one could use to generate the *roff muck? While my TeX isn't entirely fresh its at least something I've done lots of.
Quoted 3 lines
But, in that case, I need to know the
copyright and license you want to use. Please see
https://www.kernel.org/doc/man-pages/licenses.html
GPLv2 + DOC (not v2+) sounds good.
Re: sched_{set,get}attr() manpage
Quoted 13 lines · Peter Zijlstra
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Looks like a good set of comments from Juri. Could you revise and resubmit?
Yeah, I'll try and get it done today, but there's a few icky bugs waiting for my attention as well, I'll do me bestest :-)
Quoted 3 lines
By the way, I assume you are just writing this page as raw text. While I'd prefer to get proper man markup source, I'll add that if you if you don't :-/.
Quoted 5 lines
Well, learning *roff will likely take me more time than writing this text + all revisions so far :/ But yeah, I appreciate the grief.
Is there a TeX variant one could use to generate the *roff muck? While my TeX isn't entirely fresh its at least something I've done lots of.
Don't worry -- just send me the plain text; I'll do it. I appreciate you writing the text in the first place; I'll handle the rest--it won't take me too long, and probably I'll find things to fix/check on the way.
Quoted 5 lines
Quoted 3 lines
But, in that case, I need to know the
copyright and license you want to use. Please see
https://www.kernel.org/doc/man-pages/licenses.htmlGPLv2 + DOC (not v2+) sounds good.
I'm a little unclear here. Do you or don't you mean
https://www.kernel.org/doc/man-pages/licenses.html#gpl
?
(Note, I'd really prefer to stick to one of those licenses (without variants). (My personal preference is the "verbatim" license, which is the most widely used one.) There's already do many licenses in in man-pages...
Cheers,
Michael
Signature · 7 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/ -- To unsubscribe from this list: send the line "unsubscribe linux-man" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 9 lines · Michael Kerrisk (man-pages)
Quoted 5 lines
Quoted 3 lines
But, in that case, I need to know the
copyright and license you want to use. Please see
https://www.kernel.org/doc/man-pages/licenses.htmlGPLv2 + DOC (not v2+) sounds good.
I'm a little unclear here. Do you or don't you mean
https://www.kernel.org/doc/man-pages/licenses.html#gpl
?
A variant with out the +, just like I do my kernel code, no greater gpl versions. However,
Quoted 4 lines
(Note, I'd really prefer to stick to one of those licenses (without variants). (My personal preference is the "verbatim" license, which is the most widely used one.) There's already do many licenses in in man-pages...
Verbatim is OK with me I suppose. Its only text after all, who cares about that :-)
/me runs for the hills.
Re: sched_{set,get}attr() manpage
Quoted 14 lines · Peter Zijlstra
Quoted 9 lines · Michael Kerrisk (man-pages)
Quoted 5 lines
Quoted 3 lines
But, in that case, I need to know the
copyright and license you want to use. Please see
https://www.kernel.org/doc/man-pages/licenses.htmlGPLv2 + DOC (not v2+) sounds good.
I'm a little unclear here. Do you or don't you mean
https://www.kernel.org/doc/man-pages/licenses.html#gpl
?A variant with out the +, just like I do my kernel code, no greater gpl versions. However,
Quoted 6 lines
Quoted 4 lines
(Note, I'd really prefer to stick to one of those licenses (without variants). (My personal preference is the "verbatim" license, which is the most widely used one.) There's already do many licenses in in man-pages...
Verbatim is OK with me I suppose.
And don't neglect to mention who the copyright is to please.
Quoted 3 lines
Its only text after all, who cares
about that :-)
/me runs for the hills.
Well, apparently you care, so thanks ;-)
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
In reply to Peter ZijlstraQuoted 8 lines · Peter Zijlstra
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Looks like a good set of comments from Juri. Could you revise and resubmit?
Yeah, I'll try and get it done today, but there's a few icky bugs waiting for my attention as well, I'll do me bestest :-)
OK, not quite managed it yesterday, but here goes.
So Verbatim license, for the first part to me and whoever I borrowed sched_setscheduler() bits from.
For the second part to me and Juri.
---
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIs
NAME
sched_setattr, sched_getattr - set and get scheduling policy/attributes
SYNOPSIS
#include <sched.h>
struct sched_attr {
u32 size;
u32 sched_policy;
u64 sched_flags;
/* SCHED_NORMAL, SCHED_BATCH */
s32 sched_nice;
/* SCHED_FIFO, SCHED_RR */
u32 sched_priority;
/* SCHED_DEADLINE */
u64 sched_runtime;
u64 sched_deadline;
u64 sched_period;
};
int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags);
int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr() sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr() replaces sched_setscheduler(), sched_setparam(), nice() and some of setpriority().
If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHER the standard "fair" time-sharing policy;
SCHED_BATCH for "batch" style execution of processes; and
SCHED_IDLE for running very low priority background jobs.
The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFO a static priority first-in, first-out policy;
SCHED_RR a static priority round-robin policy; and
SCHED_DEADLINE a dynamic priority deadline policy.
The semantics of each of these policies are detailed in sched(7).
sched_attr::size must be set to the size of the structure, as in sizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with -E2BIG.
sched_attr::sched_policy the desired scheduling policy.
sched_attr::sched_flags additional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK - resets the scheduling policy
to: (struct sched_attr){ .sched_policy = SCHED_OTHER, } on fork().
is the only supported flag.
sched_attr::sched_nice should only be set for SCHED_OTHER, SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priority should only be set for SCHED_FIFO, SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtime in nanoseconds, sched_attr::sched_deadline in nanoseconds, sched_attr::sched_period in nanoseconds, should only be set for SCHED_DEADLINE and are the traditional sporadic task model parameters, see sched(7).
The flags argument should be 0.
sched_getattr() queries the scheduling policy currently applied to the process identified by pid.
Similar to sched_setattr(), sched_getattr() replaces sched_getscheduler(), sched_getparam() and some of getpriority().
If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct sched_attr as known to userspace. The kernel fills out sched_attr::size to the size of its sched_attr structure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with -E2BIG.
The flags argument should be 0.
The other sched_attr fields are filled out as described in sched_setattr().
RETURN VALUE
On success, sched_setattr() and sched_getattr() return 0. On error, -1 is returned, and errno is set appropriately.
ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.
EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct sched_attr is either too
big, see sched_setattr(), or too small, see sched_getattr().
EBUSY SCHED_DEADLINE admission control failure, see sched(7).
NOTES
While the text above (and in sched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.
While the SCHED_DEADLINE parameters are in nanoseconds, current kernels truncate the lower 10 bits and we get an effective microsecond resolution.
Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINE is currently implemented using GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).
A sporadic task is one that has a sequence of jobs, where each job is activated at most once per period. Each job has also a relative deadline, before which it should finish execution, and a computation time, that is the time necessary for executing the job without interruption. The instant of time when a task wakes up, because a new job has to be executed, is called arrival time (and it is also referred to as request time or release time). Start time is instead the time at which a task starts its execution. The absolute deadline is thus obtained adding the relative deadline to the arrival time.
The following diagram clarifies these terms:
arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- comp. ->|
|<---------- rel. deadline ->| |<---------- period ----------------->|
SCHED_DEADLINE allows the user to specify three parameters (see sched_setattr(2)): Runtime [ns], Deadline [ns] and Period [ns]. Such parameters has not necessarily to correspond to the aforementioned terms, while usual practise is to set Runtime to something bigger than the average computation time (or worst-case execution time for hard real-time tasks), Deadline to the relative deadline and Period to the period of the task. With such a setting we would have:
arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- Runtime -->|
|<---------- Deadline ------>| |<---------- Period ----------------->|
It is checked that: Runtime <= Deadline <= Period.
The CBS guarantees non-interference between tasks, by throttling tasks that attempt to over-run their specified Runtime.
In general the set of all SCHED_DEADLINE tasks is not feasible/schedulable within the given constraints. To guarantee some degree of timeliness we must do an admittance test on setting/changing SCHED_DEADLINE policy/attributes.
This admission test calculates that the task set is feasible/schedulable, failing this, sched_setattr() will return -EBUSY.
For example, it is required (but not necessarily sufficient) for the total utilization to be less or equal to the total amount of CPUs available, where, since each task can maximally run for Runtime per Period, that task's utilization is its Runtime/Period.
Because we must be able to calculate admittance SCHED_DEADLINE tasks are the highest priority (user controllable) tasks in the system, if any SCHED_DEADLINE task is runnable it will preempt any FIFO/RR/OTHER/BATCH/IDLE task.
SCHED_DEADLINE tasks will fail fork(2) with -EAGAIN, except when the forking task has SCHED_FLAG_RESET_ON_FORK set.
A SCHED_DEADLINE task calling sched_yield() will 'yield' the current job and wait for a new period to begin.
Re: sched_{set,get}attr() manpage
Hi Peter,
I'm working on this text. I see the following in kernel/sched/core.c:
[[
static int __sched_setscheduler(struct task_struct *p,
const struct sched_attr *attr, bool user)
{
...
int policy = attr->sched_policy;
...
if (policy < 0) {
reset_on_fork = p->sched_reset_on_fork;
policy = oldpolicy = p->policy;]]
What's a negative policy about? Is this something that should be documented?
Cheers,
Michael
Quoted 240 lines · Peter Zijlstra
Quoted 8 lines · Peter Zijlstra
Quoted 4 lines · Michael Kerrisk (man-pages)
Hi Peter,
Looks like a good set of comments from Juri. Could you revise and resubmit?
Yeah, I'll try and get it done today, but there's a few icky bugs waiting for my attention as well, I'll do me bestest :-)
OK, not quite managed it yesterday, but here goes.
So Verbatim license, for the first part to me and whoever I borrowed
sched_setscheduler()bits from.For the second part to me and Juri.
---
Quoted 1 line
[1] A page describing the
sched_setattr()andsched_getattr()APIsNAME
sched_setattr,sched_getattr- set and get scheduling policy/attributesSYNOPSIS
#include <sched.h> struct sched_attr { u32 size; u32 sched_policy; u64 sched_flags; /* SCHED_NORMAL, SCHED_BATCH */ s32 sched_nice; /* SCHED_FIFO, SCHED_RR */ u32 sched_priority; /* SCHED_DEADLINE */ u64 sched_runtime; u64 sched_deadline; u64 sched_period; }; int sched_setattr(pid_t pid, const struct sched_attr *attr, unsigned int flags); int sched_getattr(pid_t pid, const struct sched_attr *attr, unsigned int size, unsigned int flags);DESCRIPTION
sched_setattr()sets both the scheduling policy and the associated attributes for the process whose ID is specified in pid.
sched_setattr()replacessched_setscheduler(),sched_setparam(),nice()and some ofsetpriority().If pid equals zero, the scheduling policy and attributes of the calling process will be set. The interpretation of the argument attr depends on the selected policy. Currently, Linux supports the following "normal" (i.e., non-real-time) scheduling policies:
SCHED_OTHERthe standard "fair" time-sharing policy;
SCHED_BATCHfor "batch" style execution of processes; and
SCHED_IDLEfor running very low priority background jobs.The following "real-time" policies are also supported, for special time-critical applications that need precise control over the way in which runnable processes are selected for execution:
SCHED_FIFOa static priority first-in, first-out policy;
SCHED_RRa static priority round-robin policy; and
SCHED_DEADLINEa dynamic priority deadline policy.The semantics of each of these policies are detailed in sched(7).
sched_attr::sizemust be set to the size of the structure, as insizeof(struct sched_attr), if the provided structure is smaller than the kernel structure, any additional fields are assumed '0'. If the provided structure is larger than the kernel structure, the kernel verifies all additional fields are '0' if not the syscall will fail with-E2BIG.
sched_attr::sched_policythe desired scheduling policy.
sched_attr::sched_flagsadditional flags that can influence scheduling behaviour. Currently as per Linux kernel 3.14:
SCHED_FLAG_RESET_ON_FORK- resets the scheduling policy
to: (struct sched_attr){ .sched_policy =SCHED_OTHER, } onfork().is the only supported flag.
sched_attr::sched_niceshould only be set forSCHED_OTHER,SCHED_BATCH, the desired nice value [-20,19], see sched(7).
sched_attr::sched_priorityshould only be set forSCHED_FIFO,SCHED_RR, the desired static priority [1,99], see sched(7).
sched_attr::sched_runtimein nanoseconds,sched_attr::sched_deadlinein nanoseconds,sched_attr::sched_periodin nanoseconds, should only be set forSCHED_DEADLINEand are the traditional sporadic task model parameters, see sched(7).The flags argument should be 0.
sched_getattr()queries the scheduling policy currently applied to the process identified by pid.Similar to
sched_setattr(),sched_getattr()replacessched_getscheduler(),sched_getparam()and some ofgetpriority().If pid equals zero, the policy of the calling process will be retrieved.
The size argument should reflect the size of struct
sched_attras known to userspace. The kernel fills outsched_attr::sizeto the size of itssched_attrstructure. If the user provided structure is larger, additional fields are not touched. If the user provided structure is smaller, but the kernel needs to return values outside the provided space, the syscall will fail with-E2BIG.The flags argument should be 0.
The other
sched_attrfields are filled out as described insched_setattr().RETURN VALUE
On success,sched_setattr()andsched_getattr()return 0. On error, -1 is returned, and errno is set appropriately.ERRORS
EINVAL The scheduling policy is not one of the recognized policies,
param is NULL, or param does not make sense for the selected policy.EPERM The calling process does not have appropriate privileges.
ESRCH The process whose ID is pid could not be found.
E2BIG The provided storage for struct
sched_attris either too
big, seesched_setattr(), or too small, seesched_getattr().EBUSY
SCHED_DEADLINEadmission control failure, see sched(7).NOTES
While the text above (and insched_setscheduler(2)) talks about processes, in actual fact these system calls are thread specific.While the
SCHED_DEADLINEparameters are in nanoseconds, current kernels truncate the lower 10 bits and we get an effective microsecond resolution.Quoted 2 lines
[2] A piece of text describing the
SCHED_DEADLINEpolicy, which I can drop into sched(7).
SCHED_DEADLINE: Sporadic task model deadline scheduling
SCHED_DEADLINEis currently implemented using GEDF (Global Earliest Deadline First) with additional CBS (Constant Bandwidth Server).A sporadic task is one that has a sequence of jobs, where each job is activated at most once per period. Each job has also a relative deadline, before which it should finish execution, and a computation time, that is the time necessary for executing the job without interruption. The instant of time when a task wakes up, because a new job has to be executed, is called arrival time (and it is also referred to as request time or release time). Start time is instead the time at which a task starts its execution. The absolute deadline is thus obtained adding the relative deadline to the arrival time.
The following diagram clarifies these terms:
arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- comp. ->|
|<---------- rel. deadline ->| |<---------- period ----------------->|
SCHED_DEADLINEallows the user to specify three parameters (seesched_setattr(2)): Runtime [ns], Deadline [ns] and Period [ns]. Such parameters has not necessarily to correspond to the aforementioned terms, while usual practise is to set Runtime to something bigger than the average computation time (or worst-case execution time for hard real-time tasks), Deadline to the relative deadline and Period to the period of the task. With such a setting we would have:arrival/wakeup absolute deadline
| start time |
v v v
-------x--------xoooooooooooo-------x--------x-----
|<- Runtime -->|
|<---------- Deadline ------>| |<---------- Period ----------------->|It is checked that: Runtime <= Deadline <= Period.
The CBS guarantees non-interference between tasks, by throttling tasks that attempt to over-run their specified Runtime.
In general the set of all
SCHED_DEADLINEtasks is not feasible/schedulable within the given constraints. To guarantee some degree of timeliness we must do an admittance test on setting/changingSCHED_DEADLINEpolicy/attributes.This admission test calculates that the task set is feasible/schedulable, failing this,
sched_setattr()will return-EBUSY.For example, it is required (but not necessarily sufficient) for the total utilization to be less or equal to the total amount of CPUs available, where, since each task can maximally run for Runtime per Period, that task's utilization is its Runtime/Period.
Because we must be able to calculate admittance
SCHED_DEADLINEtasks are the highest priority (user controllable) tasks in the system, if anySCHED_DEADLINEtask is runnable it will preempt any FIFO/RR/OTHER/BATCH/IDLE task.
SCHED_DEADLINEtasks will fail fork(2) with-EAGAIN, except when the forking task hasSCHED_FLAG_RESET_ON_FORKset.A
SCHED_DEADLINEtask callingsched_yield()will 'yield' the current job and wait for a new period to begin.
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
Peter Zijlstra
maintainerRe: sched_{set,get}attr() manpage
Quoted 16 lines · Michael Kerrisk (man-pages)
Hi Peter,
I'm working on this text. I see the following in
kernel/sched/core.c:[[
static int __sched_setscheduler(structtask_struct*p,
const structsched_attr*attr, bool user){ ... int policy = attr->sched_policy; ... if (policy < 0) { reset_on_fork = p->sched_reset_on_fork; policy = oldpolicy = p->policy;
Quoted 4 lines
]]
What's a negative policy about? Is this something that should be documented?
That's for sched_setparam(), which internally passes policy = -1, it wasn't meant to be user visible, lemme double check that.
sys_sched_setscheduler() -- explicit check for policy < 0 sys_sched_setparam() -- explicitly passes policy=-1, not user visible sys_sched_setattr() -- hmm, it looks like fail
---
Subject: sched: Disallow sched_attr::sched_policy < 0
From: Peter Zijlstra <[email protected]>
Date: Fri May 9 10:49:03 CEST 2014
The scheduler uses policy=-1 to preserve the current policy state to implement sys_sched_setparam(), this got exposed to userspace by accident through sys_sched_setattr(), cure this.
--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/sched/core.c +3 -0
@@ -3711,6 +3711,9 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, piif (sched_copy_attr (uattr, &attr))return -EFAULT ; +if (attr.sched_policy <0 ) +return -EINVAL ; +rcu_read_lock (); retval = -ESRCH ; p =find_process_by_pid (pid);
Michael Kerrisk (man-pages)
Acked-byRe: sched_{set,get}attr() manpage
Hi Peter,
Quoted 19 lines · Peter Zijlstra
Quoted 18 lines · Michael Kerrisk (man-pages)
Hi Peter,
I'm working on this text. I see the following in
kernel/sched/core.c:[[
static int __sched_setscheduler(structtask_struct*p,
const structsched_attr*attr, bool user){ ... int policy = attr->sched_policy; ... if (policy < 0) { reset_on_fork = p->sched_reset_on_fork; policy = oldpolicy = p->policy;]]
Quoted 8 lines
Quoted 2 lines
What's a negative policy about? Is this something that should be documented?
That's for
sched_setparam(), which internally passes policy = -1, it wasn't meant to be user visible, lemme double check that.
sys_sched_setscheduler()-- explicit check for policy < 0sys_sched_setparam()-- explicitly passes policy=-1, not user visible
(Ahh -- I missed that piece in sys_sched_setparam())
Quoted 1 line
sys_sched_setattr()-- hmm, it looks like fail
Yep, I was seeing that there was no check in sched_setatr().
As I recently said, when it comes to writing a man page, show me a new interface, and I'll show you a bug ;-).
Thanks for the clarification.
Cheers,
Michael
Quoted 28 lines
---
Subject: sched: Disallowsched_attr::sched_policy< 0
From: Peter Zijlstra <[email protected]>
Date: Fri May 9 10:49:03 CEST 2014The scheduler uses policy=-1 to preserve the current policy state to implement
sys_sched_setparam(), this got exposed to userspace by accident throughsys_sched_setattr(), cure this.Reported-by Michael Kerrisk <[email protected]>Signed-off-by Peter Zijlstra <[email protected]>--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)kernel/sched/core.c +3
-0@@ -3711,6 +3711,9 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, piif (sched_copy_attr (uattr, &attr))return -EFAULT ; +if (attr.sched_policy <0 ) +return -EINVAL ; +rcu_read_lock (); retval = -ESRCH ; p =find_process_by_pid (pid);
Signature · 3 lines
Michael Kerrisk Linux man-pages maintainer; http://www.kernel.org/doc/man-pages/ Linux/UNIX System Programming Training: http://man7.org/training/
tip-bot for Peter Zijlstra
merge bot[tip:sched/core] sched: Disallow sched_attr::sched_policy < 0
In reply to Peter Zijlstrasched: Disallow sched_attr::sched_policy < 0
Commit-ID: 438367fbfe307f2c26ee8e490f1fb9eacb6b6b02 Gitweb: http://git.kernel.org/tip/438367fbfe307f2c26ee8e490f1fb9eacb6b6b02 Author: Peter Zijlstra <[email protected]> AuthorDate: Fri, 9 May 2014 10:49:03 +0200 Committer: Thomas Gleixner <[email protected]> CommitDate: Mon, 19 May 2014 21:47:33 +0900
sched: Disallow sched_attr::sched_policy < 0
The scheduler uses policy=-1 to preserve the current policy state to implement sys_sched_setparam(), this got exposed to userspace by accident through sys_sched_setattr(), cure this.
--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/sched/core.c +3 -0
@@ -3662,6 +3662,9 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (retval)return retval; +if (attr.sched_policy <0 ) +return -EINVAL ; +rcu_read_lock (); retval = -ESRCH ; p =find_process_by_pid (pid);
tip-bot for Peter Zijlstra
merge bot[tip:sched/core] sched: Disallow sched_attr::sched_policy < 0
In reply to Peter Zijlstrasched: Disallow sched_attr::sched_policy < 0
Commit-ID: dbdb22754fde671dc93d2fae06f8be113d47f2fb Gitweb: http://git.kernel.org/tip/dbdb22754fde671dc93d2fae06f8be113d47f2fb Author: Peter Zijlstra <[email protected]> AuthorDate: Fri, 9 May 2014 10:49:03 +0200 Committer: Ingo Molnar <[email protected]> CommitDate: Thu, 22 May 2014 10:21:26 +0200
sched: Disallow sched_attr::sched_policy < 0
The scheduler uses policy=-1 to preserve the current policy state to implement sys_sched_setparam(), this got exposed to userspace by accident through sys_sched_setattr(), cure this.
--- kernel/sched/core.c | 3 +++ 1 file changed, 3 insertions(+)
kernel/sched/core.c +3 -0
@@ -3662,6 +3662,9 @@ SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr,if (retval)return retval; +if (attr.sched_policy <0 ) +return -EINVAL ; +rcu_read_lock (); retval = -ESRCH ; p =find_process_by_pid (pid);
tip-bot for Peter Zijlstra
merge bot[tip:sched/urgent] sched: Add 'flags' argument to sched_{set, get}attr() syscalls
In reply to Peter Zijlstrasched: Add 'flags' argument to sched_{set,get}attr() syscalls
Commit-ID: 6d35ab48090b10c5ea5604ed5d6e91f302dc6060 Gitweb: http://git.kernel.org/tip/6d35ab48090b10c5ea5604ed5d6e91f302dc6060 Author: Peter Zijlstra <[email protected]> AuthorDate: Fri, 14 Feb 2014 17:19:29 +0100 Committer: Thomas Gleixner <[email protected]> CommitDate: Fri, 21 Feb 2014 21:27:10 +0100
sched: Add 'flags' argument to sched_{set,get}attr() syscalls
Because of a recent syscall design debate; its deemed appropriate for each syscall to have a flags argument for future extension; without immediately requiring new syscalls.
--- include/linux/syscalls.h | 6 ++++-- kernel/sched/core.c | 11 ++++++----- 2 files changed, 10 insertions(+), 7 deletions(-)
include/linux/syscalls.h +4 -2
@@ -281,13 +281,15 @@ asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_setattr (pid_t pid, -struct sched_attr __user *attr); +struct sched_attr __user *attr, +unsigned int flags);asmlinkage long sys_sched_getscheduler (pid_t pid);asmlinkage long sys_sched_getparam (pid_t pid,struct sched_param __user *param);asmlinkage long sys_sched_getattr (pid_t pid,struct sched_attr __user *attr, -unsigned int size); +unsigned int size, +unsigned int flags);asmlinkage long sys_sched_setaffinity (pid_t pid,unsigned int len,unsigned long __user *user_mask_ptr); asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
kernel/sched/core.c +6 -5
@@ -3661,13 +3661,14 @@ SYSCALL_DEFINE2(sched_setparam, pid_t, pid, struct sched_param __user *, param)* @pid: the pid in question. * @uattr: structure containing the extended parameters. */ -SYSCALL_DEFINE2(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr) +SYSCALL_DEFINE3(sched_setattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned int, flags) {struct sched_attr attr;struct task_struct *p;int retval; -if (!uattr || pid <0 ) +if (!uattr || pid <0 || flags)return -EINVAL ;if (sched_copy_attr (uattr, &attr))
@@ -3804,8 +3805,8 @@ err_size:* @uattr: structure containing the extended parameters. * @size: sizeof(attr) for fwd/bwd comp. */ -SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, - unsigned int, size) +SYSCALL_DEFINE4(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr, + unsigned int, size, unsigned int, flags) {struct sched_attr attr = { .size =sizeof (struct sched_attr ),
@@ -3814,7 +3815,7 @@ SYSCALL_DEFINE3(sched_getattr, pid_t, pid, struct sched_attr __user *, uattr,int retval;if (!uattr || pid <0 || size >PAGE_SIZE || - size <SCHED_ATTR_SIZE_VER0 ) + size <SCHED_ATTR_SIZE_VER0 || flags)return -EINVAL ;rcu_read_lock ();
Re: [PATCH 01/13] sched: Add 3 new scheduler syscalls to support an extended scheduling parameters ABI
In reply to Peter ZijlstraQuoted 5 lines · Peter Zijlstra
From: Dario Faggioli <[email protected]>
Add the syscalls needed for supporting scheduling algorithms with extended scheduling parameters (e.g.,
SCHED_DEADLINE).
Quoted 7 lines
- defines and implements the new scheduling related syscalls that manipulate it, i.e.,
sched_setscheduler2(),sched_setattr()andsched_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.
Please cc linux-arch on new syscalls.
They're now in mainline, and in the end there are only 2 (sched_setattr() and sched_getattr()).
Gr{oetje,eeting}s,
Geert
--
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]
In personal conversations with technical people, I call myself a hacker. But when I'm talking to journalists I just say "programmer" or something like that.
-- Linus Torvalds
Peter Zijlstra
maintainerPATCH 2/13 sched: SCHED_DEADLINE structures & implementation
In reply to Peter ZijlstraFrom: Dario Faggioli <[email protected]>
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.
--- arch/arm/include/asm/unistd.h | 2 include/linux/sched.h | 46 ++ include/linux/sched/deadline.h | 24 + include/uapi/linux/sched.h | 1 kernel/fork.c | 4 kernel/hrtimer.c | 3 kernel/sched/Makefile | 3 kernel/sched/core.c | 109 +++++- kernel/sched/deadline.c | 684 +++++++++++++++++++++++++++++++++++++++++ kernel/sched/sched.h | 28 + kernel/sched/stop_task.c | 2 11 files changed, 885 insertions(+), 21 deletions(-) create mode 100644 include/linux/sched/deadline.h create mode 100644 kernel/sched/deadline.c
include/linux/sched.h +45 -1
@@ -95,6 +95,10 @@ struct sched_param {* timing constraints. * * @size size of the structure, for fwd/bwd compat. +* +* As of now, the SCHED_DEADLINE policy (sched_dl scheduling class) is the +* only user of this new interface. More information about the algorithm +* available in the scheduling class file or in Documentation/. */ struct sched_attr {int sched_priority;
@@ -1080,6 +1084,45 @@ struct sched_rt_entity {#endif }; +struct sched_dl_entity { +struct rb_node rb_node; + +/* +* Original scheduling parameters. Copied here from sched_attr +* during sched_setscheduler2(), they will remain the same until +* the next sched_setscheduler2(). +*/ +u64 dl_runtime;/* maximum runtime for each instance */ +u64 dl_deadline;/* relative deadline of each instance */ + +/* +* Actual scheduling parameters. Initialized with the values above, +* they are continously updated during task execution. Note that +* the remaining runtime could be < 0 in case we are in overrun. +*/ +s64 runtime;/* remaining runtime for this instance */ +u64 deadline;/* absolute deadline for this instance */ +unsigned int flags;/* specifying the scheduler behaviour */ + +/* +* Some bool flags: +* +* @dl_throttled tells if we exhausted the runtime. If so, the +* task has to wait for a replenishment to be performed at the +* next firing of dl_timer. +* +* @dl_new tells if a new instance arrived. If so we must +* start executing it with full runtime and reset its absolute +* deadline; +*/ +int dl_throttled, dl_new; + +/* +* Bandwidth enforcement timer. Each -deadline task has its +* own bandwidth to be enforced, thus we need one timer per task. +*/ +struct hrtimer dl_timer; +};struct rcu_node ;
@@ -1116,6 +1159,7 @@ struct task_struct {#ifdef CONFIG_CGROUP_SCHED struct task_group *sched_task_group;#endif +struct sched_dl_entity dl;#ifdef CONFIG_PREEMPT_NOTIFIERS /* list of struct preempt_notifier: */
@@ -2093,7 +2137,7 @@ extern void wake_up_new_task(struct task#else static inline void kick_process (struct task_struct *tsk) { }#endif -extern void sched_fork (unsigned long clone_flags,struct task_struct *p); +extern int sched_fork (unsigned long clone_flags,struct task_struct *p);extern void sched_dead (struct task_struct *p);extern void proc_caches_init (void );
include/linux/sched/deadline.h new file +24 -0
@@ -0,0 +1,24 @@ +#ifndef _SCHED_DEADLINE_H +#define _SCHED_DEADLINE_H + +/* +* SCHED_DEADLINE tasks has negative priorities, reflecting +* the fact that any of them has higher prio than RT and +* NORMAL/BATCH tasks. +*/ + +#define MAX_DL_PRIO 0 + +static inline int dl_prio (int prio) +{ +if (unlikely (prio <MAX_DL_PRIO )) +return 1 ; +return 0 ; +} + +static inline int dl_task (struct task_struct *p) +{ +return dl_prio (p->prio); +} + +#endif /* _SCHED_DEADLINE_H */
include/uapi/linux/sched.h +1 -0
@@ -39,6 +39,7 @@#define SCHED_BATCH 3/* SCHED_ISO: reserved but not implemented yet */ #define SCHED_IDLE 5 +#define SCHED_DEADLINE 6/* Can be ORed in to make sure the process is reverted back to SCHED_NORMAL on fork */ #define SCHED_RESET_ON_FORK 0x40000000
kernel/fork.c +3 -1
@@ -1310,7 +1310,9 @@ static struct task_struct *copy_process(#endif /* Perform scheduler related setup. Assign this task to a CPU. */ -sched_fork (clone_flags, p); + retval =sched_fork (clone_flags, p); +if (retval) + goto bad_fork_cleanup_policy; retval =perf_event_init_task (p);if (retval)
kernel/hrtimer.c +2 -1
@@ -46,6 +46,7 @@#include <linux/sched.h> #include <linux/sched/sysctl.h> #include <linux/sched/rt.h> +#include <linux/sched/deadline.h> #include <linux/timer.h> #include <linux/freezer.h>
@@ -1610,7 +1611,7 @@ long hrtimer_nanosleep(struct timespec *unsigned long slack; slack = current->timer_slack_ns; -if (rt_task (current)) +if (dl_task (current) ||rt_task (current)) slack =0 ;hrtimer_init_on_stack (&t.timer, clockid, mode);
kernel/sched/Makefile +2 -1
@@ -11,7 +11,8 @@ ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER CFLAGS_core.o := $(PROFILING) -fno-omit-frame-pointer endif -obj-y += core.o proc.o clock.o cputime.o idle_task.o fair.o rt.o stop_task.o +obj-y += core.o proc.o clock.o cputime.o +obj-y += idle_task.o fair.o rt.o deadline.o stop_task.o obj-y += wait.o completion.o obj-$(CONFIG_SMP) += cpupri.o obj-$(CONFIG_SCHED_AUTOGROUP) += auto_group.o
kernel/sched/core.c +94 -15
250 lines not on this page · raw message
kernel/sched/deadline.c new file +684 -0
684 lines not on this page · raw message
kernel/sched/sched.h +28 -0
@@ -2,6 +2,7 @@#include <linux/sched.h> #include <linux/sched/sysctl.h> #include <linux/sched/rt.h> +#include <linux/sched/deadline.h> #include <linux/mutex.h> #include <linux/spinlock.h> #include <linux/stop_machine.h>
@@ -88,11 +89,23 @@ static inline int rt_policy(int policy)return 0 ; } +static inline int dl_policy (int policy) +{ +if (unlikely (policy ==SCHED_DEADLINE )) +return 1 ; +return 0 ; +} +static inline int task_has_rt_policy (struct task_struct *p) {return rt_policy (p->policy); } +static inline int task_has_dl_policy (struct task_struct *p) +{ +return dl_policy (p->policy); +} +/* * This is the priority-queue data structure of the RT scheduling class: */
@@ -364,6 +377,15 @@ struct rt_rq {#endif }; +/* 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; +}; +#ifdef CONFIG_SMP /*
@@ -432,6 +454,7 @@ struct rq {struct cfs_rq cfs;struct rt_rq rt; +struct dl_rq dl;#ifdef CONFIG_FAIR_GROUP_SCHED /* list of leaf cfs_rq on this cpu: */
@@ -988,6 +1011,7 @@ static const u32 prio_to_wmult[40] = {#else #define ENQUEUE_WAKING 0#endif +#define ENQUEUE_REPLENISH 8#define DEQUEUE_SLEEP 1
@@ -1043,6 +1067,7 @@ struct sched_class {for (class = sched_class_highest; class; class = class->next) extern const struct sched_class stop_sched_class; +extern const struct sched_class dl_sched_class;extern const struct sched_class rt_sched_class;extern const struct sched_class fair_sched_class;extern const struct sched_class idle_sched_class;
@@ -1078,6 +1103,8 @@ 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); +extern void init_dl_task_timer (struct sched_dl_entity *dl_se); +extern void update_idle_cpu_load (struct rq *this_rq);extern void init_task_runnable_average (struct task_struct *p);
@@ -1354,6 +1381,7 @@ extern void print_rt_stats(struct seq_fiextern void init_cfs_rq (struct cfs_rq *cfs_rq);extern void init_rt_rq (struct rt_rq *rt_rq,struct rq *rq); +extern void init_dl_rq (struct dl_rq *dl_rq,struct rq *rq);extern void cfs_bandwidth_usage_inc (void );extern void cfs_bandwidth_usage_dec (void );
kernel/sched/stop_task.c +1 -1
@@ -103,7 +103,7 @@ get_rr_interval_stop(struct rq *rq, stru* Simple, special scheduling class for the per-CPU stop tasks: */ const struct sched_class stop_sched_class = { - .next = &rt_sched_class, + .next = &dl_sched_class, .enqueue_task = enqueue_task_stop, .dequeue_task = dequeue_task_stop,
Peter Zijlstra
maintainerPATCH 3/13 sched: SCHED_DEADLINE SMP-related data structures & logic
In reply to Peter ZijlstraFrom: Juri Lelli <[email protected]>
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.
--- include/linux/sched.h | 1 kernel/sched/core.c | 9 kernel/sched/deadline.c | 934 +++++++++++++++++++++++++++++++++++++++++++++++- kernel/sched/rt.c | 2 kernel/sched/sched.h | 34 + 5 files changed, 963 insertions(+), 17 deletions(-)
include/linux/sched.h +1 -0
@@ -1193,6 +1193,7 @@ struct task_struct {struct list_head tasks;#ifdef CONFIG_SMP struct plist_node pushable_tasks; +struct rb_node pushable_dl_tasks;#endif struct mm_struct *mm, *active_mm;
kernel/sched/core.c +8 -1
@@ -1847,6 +1847,7 @@ int sched_fork(unsigned long clone_flagsinit_task_preempt_count (p);#ifdef CONFIG_SMP plist_node_init (&p->pushable_tasks,MAX_PRIO ); +RB_CLEAR_NODE (&p->pushable_dl_tasks);#endif put_cpu ();
@@ -5031,6 +5032,7 @@ static void free_rootdomain(struct rcu_h struct root_domain *rd = container_of(rcu, struct root_domain, rcu);cpupri_cleanup (&rd->cpupri); +free_cpumask_var (rd->dlo_mask);free_cpumask_var (rd->rto_mask);free_cpumask_var (rd->online);free_cpumask_var (rd->span);
@@ -5082,8 +5084,10 @@ static int init_rootdomain(struct root_d goto out;if (!alloc_cpumask_var (&rd->online,GFP_KERNEL )) goto free_span; -if (!alloc_cpumask_var (&rd->rto_mask,GFP_KERNEL )) +if (!alloc_cpumask_var (&rd->dlo_mask,GFP_KERNEL )) goto free_online; +if (!alloc_cpumask_var (&rd->rto_mask,GFP_KERNEL )) + goto free_dlo_mask;if (cpupri_init (&rd->cpupri) !=0 ) goto free_rto_mask;
@@ -5091,6 +5095,8 @@ static int init_rootdomain(struct root_d free_rto_mask:free_cpumask_var (rd->rto_mask); +free_dlo_mask: +free_cpumask_var (rd->dlo_mask); free_online:free_cpumask_var (rd->online); free_span:
@@ -6441,6 +6447,7 @@ void __init sched_init_smp(void)free_cpumask_var (non_isolated_cpus);init_sched_rt_class (); + init_sched_dl_class(); }#else void __init sched_init_smp (void )
kernel/sched/deadline.c +919 -15
1,055 lines not on this page · raw message
kernel/sched/rt.c +1 -1
@@ -1738,7 +1738,7 @@ static void task_woken_rt(struct rq *rq, !test_tsk_need_resched (rq->curr) &&has_pushable_tasks (rq) && p->nr_cpus_allowed >1 && - rt_task(rq->curr) && + (dl_task (rq->curr) ||rt_task (rq->curr)) && (rq->curr->nr_cpus_allowed <2 || rq->curr->prio <= p->prio)) push_rt_tasks(rq);
kernel/sched/sched.h +34 -0
@@ -384,6 +384,31 @@ struct dl_rq {struct rb_node *rb_leftmost;unsigned long dl_nr_running; + +#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; +unsigned long dl_nr_total; +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; +#endif };#ifdef CONFIG_SMP
@@ -404,6 +429,13 @@ struct root_domain {cpumask_var_t online;/* +* 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; + +/* * The "RT overload" flag: it gets set if a CPU has more than * one runnable RT task. */
@@ -1094,6 +1126,8 @@ static inline void idle_balance(int cpu,extern void sysrq_sched_debug_show (void );extern void sched_init_granularity (void );extern void update_max_interval (void ); + +extern void init_sched_dl_class (void );extern void init_sched_rt_class (void );extern void init_sched_fair_class (void );
Peter Zijlstra
maintainerPATCH 5/13 sched: SCHED_DEADLINE avg_update accounting
In reply to Peter ZijlstraFrom: Dario Faggioli <[email protected]>
Make the core scheduler and load balancer aware of the load produced by -deadline tasks, by updating the moving average like for sched_rt.
--- kernel/sched/deadline.c | 2 ++ 1 file changed, 2 insertions(+)
kernel/sched/deadline.c +2 -0
@@ -564,6 +564,8 @@ static void update_curr_dl(struct rq *rq) curr->se.exec_start =rq_clock_task (rq);cpuacct_charge (curr, delta_exec); +sched_rt_avg_update (rq, delta_exec); + dl_se->runtime -= delta_exec;if (dl_runtime_exceeded (rq, dl_se)) {__dequeue_task_dl (rq, curr,0 );
Signature · 1 line
1.7.10.4
Peter Zijlstra
maintainerPATCH 5/13 sched: Add period support for -deadline tasks
In reply to Peter ZijlstraFrom: Harald Gustafsson <[email protected]>
Make it possible to specify a period (different or equal than deadline) for -deadline tasks. Relative deadlines (D_i) are used on task arrivals to generate new scheduling (absolute) deadlines as "d = t + D_i", and periods (P_i) to postpone the scheduling deadlines as "d = d + P_i" when the budget is zero.
This is in general useful to model (and schedule) tasks that have slow activation rates (long periods), but have to be scheduled soon once activated (short deadlines).
--- include/linux/sched.h | 1 + kernel/sched/core.c | 10 ++++++++-- kernel/sched/deadline.c | 10 +++++++--- 3 files changed, 16 insertions(+), 5 deletions(-)
include/linux/sched.h +1 -0
@@ -1094,6 +1094,7 @@ struct sched_dl_entity {*/ u64 dl_runtime;/* maximum runtime for each instance */ u64 dl_deadline;/* relative deadline of each instance */ +u64 dl_period;/* separation of two instances (period) */ /* * Actual scheduling parameters. Initialized with the values above,
kernel/sched/core.c +8 -2
@@ -1722,6 +1722,7 @@ static void __sched_fork(unsigned long chrtimer_init (&p->dl.dl_timer,CLOCK_MONOTONIC ,HRTIMER_MODE_REL ); p->dl.dl_runtime = p->dl.runtime =0 ; p->dl.dl_deadline = p->dl.deadline =0 ; + p->dl.dl_period =0 ; p->dl.flags =0 ;INIT_LIST_HEAD (&p->rt.run_list);
@@ -3042,6 +3043,7 @@ __setparam_dl(struct task_struct *p, coninit_dl_task_timer (dl_se); dl_se->dl_runtime = attr->sched_runtime; dl_se->dl_deadline = attr->sched_deadline; + dl_se->dl_period = attr->sched_period ?: dl_se->dl_deadline; dl_se->flags = attr->sched_flags; dl_se->dl_throttled =0 ; dl_se->dl_new =1 ;
@@ -3055,19 +3057,23 @@ __getparam_dl(struct task_struct *p, str attr->sched_priority = p->rt_priority; attr->sched_runtime = dl_se->dl_runtime; attr->sched_deadline = dl_se->dl_deadline; + attr->sched_period = dl_se->dl_period; attr->sched_flags = dl_se->flags; }/* * This function validates the new parameters of a -deadline task. * We ask for the deadline not being zero, and greater or equal -* than the runtime. +* than the runtime, as well as the period of being zero or +* greater than deadline. */ static bool __checkparam_dl (const struct sched_attr *attr) {return attr && attr->sched_deadline !=0 && - (s64)(attr->sched_deadline - attr->sched_runtime) >=0 ; + (attr->sched_period ==0 || + (s64)(attr->sched_period - attr->sched_deadline) >=0 ) && + (s64)(attr->sched_deadline - attr->sched_runtime ) >=0 ; }/*
kernel/sched/deadline.c +7 -3
@@ -289,7 +289,7 @@ static void replenish_dl_entity(struct s* arbitrary large. */ while (dl_se->runtime <=0 ) { - dl_se->deadline += dl_se->dl_deadline; + dl_se->deadline += dl_se->dl_period; dl_se->runtime += dl_se->dl_runtime; }
@@ -329,9 +329,13 @@ static void replenish_dl_entity(struct s* * This function returns true if: * -* runtime / (deadline - t) > dl_runtime / dl_deadline , +* runtime / (deadline - t) > dl_runtime / dl_period , * * IOW we can't recycle current parameters. +* +* Notice that the bandwidth check is done against the period. For +* task with deadline equal to period this is the same of using +* dl_deadline instead of dl_period in the equation above. */ static bool dl_entity_overflow (struct sched_dl_entity *dl_se,u64 t) {
@@ -355,7 +359,7 @@ static bool dl_entity_overflow(struct sc* of anything below microseconds resolution is actually fiction * (but still we want to give the user that illusion >;). */ - left = (dl_se->dl_deadline >>10 ) * (dl_se->runtime >>10 ); + left = (dl_se->dl_period >>10 ) * (dl_se->runtime >>10 ); right = ((dl_se->deadline - t) >>10 ) * (dl_se->dl_runtime >>10 );return dl_time_before (right, left);
Peter Zijlstra
maintainerPATCH 7/13 rtmutex: Turn the plist into an rb-tree
In reply to Peter ZijlstraTurn the pi-chains from plist to rb-tree, in the rt_mutex code, and provide a proper comparison function for -deadline and -priority tasks.
This is done mainly because:
- classical prio field of the plist is just an int, which might not be enough for representing a deadline;
- manipulating such a list would become O(nr_deadline_tasks), which might be to much, as the number of -deadline task increases.
Therefore, an rb-tree is used, and tasks are queued in it according to the following logic:
- among two -priority (i.e., SCHED_BATCH/OTHER/RR/FIFO) tasks, the one with the higher (lower, actually!) prio wins;
- among a -priority and a -deadline task, the latter always wins;
- among two -deadline tasks, the one with the earliest deadline wins.
Queueing and dequeueing functions are changed accordingly, for both the list of a task's pi-waiters and the list of tasks blocked on a pi-lock.
--- include/linux/init_task.h | 10 ++ include/linux/rtmutex.h | 18 +--- include/linux/sched.h | 4 - kernel/fork.c | 3 kernel/futex.c | 2 kernel/locking/rtmutex-debug.c | 8 -- kernel/locking/rtmutex.c | 151 ++++++++++++++++++++++++++++++++-------- kernel/locking/rtmutex_common.h | 22 ++--- kernel/sched/core.c | 4 - 9 files changed, 157 insertions(+), 65 deletions(-)
include/linux/init_task.h +10 -0
@@ -11,6 +11,7 @@#include <linux/user_namespace.h> #include <linux/securebits.h> #include <linux/seqlock.h> +#include <linux/rbtree.h> #include <net/net_namespace.h> #include <linux/sched/rt.h>
@@ -154,6 +155,14 @@ extern struct task_group root_task_group#define INIT_TASK_COMM "swapper" +#ifdef CONFIG_RT_MUTEXES +# define INIT_RT_MUTEXES (tsk) \ + .pi_waiters = RB_ROOT, \ + .pi_waiters_leftmost = NULL, +#else +# define INIT_RT_MUTEXES (tsk) +#endif +/* * INIT_TASK is used to set up the first task table, touch at * your own risk!. Base=0, limit=0x1fffff (=2MB)
@@ -221,6 +230,7 @@ extern struct task_group root_task_group INIT_TRACE_RECURSION \ INIT_TASK_RCU_PREEMPT(tsk) \ INIT_CPUSET_SEQ(tsk) \ + INIT_RT_MUTEXES(tsk) \ INIT_VTIME(tsk) \ }
include/linux/rtmutex.h +6 -12
@@ -13,7 +13,7 @@#define __LINUX_RT_MUTEX_H#include <linux/linkage.h> -#include <linux/plist.h> +#include <linux/rbtree.h> #include <linux/spinlock_types.h> extern int max_lock_depth;/* for sysctl */
@@ -22,12 +22,14 @@ extern int max_lock_depth; /* for sysctl* The rt_mutex structure * * @wait_lock: spinlock to protect the structure -* @wait_list: pilist head to enqueue waiters in priority order +* @waiters: rbtree root to enqueue waiters in priority order +* @waiters_leftmost: top waiter * @owner: the mutex owner */ struct rt_mutex {raw_spinlock_t wait_lock; -struct plist_head wait_list; +struct rb_root waiters; +struct rb_node *waiters_leftmost;struct task_struct *owner;#ifdef CONFIG_DEBUG_RT_MUTEXES int save_state;
@@ -66,7 +68,7 @@ struct hrtimer_sleeper;#define __RT_MUTEX_INITIALIZER (mutexname) \ { .wait_lock = __RAW_SPIN_LOCK_UNLOCKED(mutexname.wait_lock) \ - , .wait_list = PLIST_HEAD_INIT(mutexname.wait_list) \ + , .waiters = RB_ROOT \ , .owner = NULL \ __DEBUG_RT_MUTEX_INITIALIZER(mutexname)}
@@ -98,12 +100,4 @@ extern int rt_mutex_trylock(struct rt_muextern void rt_mutex_unlock (struct rt_mutex *lock); -#ifdef CONFIG_RT_MUTEXES -# define INIT_RT_MUTEXES (tsk) \ - .pi_waiters = PLIST_HEAD_INIT(tsk.pi_waiters), \ - INIT_RT_MUTEX_DEBUG(tsk) -#else -# define INIT_RT_MUTEXES (tsk) -#endif -#endif
include/linux/sched.h +3 -1
@@ -16,6 +16,7 @@ struct sched_param {#include <linux/types.h> #include <linux/timex.h> #include <linux/jiffies.h> +#include <linux/plist.h> #include <linux/rbtree.h> #include <linux/thread_info.h> #include <linux/cpumask.h>
@@ -1346,7 +1347,8 @@ struct task_struct {#ifdef CONFIG_RT_MUTEXES /* PI waiters blocked on a rt_mutex held by this task */ -struct plist_head pi_waiters; +struct rb_root pi_waiters; +struct rb_node *pi_waiters_leftmost;/* Deadlock detection and priority inheritance handling */ struct rt_mutex_waiter *pi_blocked_on;#endif
kernel/fork.c +2 -1
@@ -1086,7 +1086,8 @@ static void rt_mutex_init_task(struct ta {raw_spin_lock_init (&p->pi_lock);#ifdef CONFIG_RT_MUTEXES -plist_head_init (&p->pi_waiters); + p->pi_waiters =RB_ROOT ; + p->pi_waiters_leftmost =NULL ; p->pi_blocked_on =NULL ;#endif }
kernel/futex.c +2 -0
@@ -2315,6 +2315,8 @@ static int futex_wait_requeue_pi(u32 __u* code while we sleep on uaddr. */ debug_rt_mutex_init_waiter (&rt_waiter); +RB_CLEAR_NODE (&rt_waiter.pi_tree_entry); +RB_CLEAR_NODE (&rt_waiter.tree_entry); rt_waiter.task =NULL ; ret =get_futex_key (uaddr2, flags &FLAGS_SHARED , &key2,VERIFY_WRITE );
kernel/locking/rtmutex-debug.c +2 -6
@@ -24,7 +24,7 @@#include <linux/kallsyms.h> #include <linux/syscalls.h> #include <linux/interrupt.h> -#include <linux/plist.h> +#include <linux/rbtree.h> #include <linux/fs.h> #include <linux/debug_locks.h>
@@ -57,7 +57,7 @@ static void printk_lock(struct rt_mutexvoid rt_mutex_debug_task_free (struct task_struct *task) { -DEBUG_LOCKS_WARN_ON (!plist_head_empty (&task->pi_waiters)); +DEBUG_LOCKS_WARN_ON (!RB_EMPTY_ROOT (&task->pi_waiters));DEBUG_LOCKS_WARN_ON (task->pi_blocked_on); }
@@ -154,16 +154,12 @@ void debug_rt_mutex_proxy_unlock(structvoid debug_rt_mutex_init_waiter (struct rt_mutex_waiter *waiter) {memset (waiter,0x11 ,sizeof (*waiter)); -plist_node_init (&waiter->list_entry,MAX_PRIO ); -plist_node_init (&waiter->pi_list_entry,MAX_PRIO ); waiter->deadlock_task_pid =NULL ; }void debug_rt_mutex_free_waiter (struct rt_mutex_waiter *waiter) {put_pid (waiter->deadlock_task_pid); -DEBUG_LOCKS_WARN_ON (!plist_node_empty (&waiter->list_entry)); -DEBUG_LOCKS_WARN_ON (!plist_node_empty (&waiter->pi_list_entry));memset (waiter,0x22 ,sizeof (*waiter)); }
kernel/locking/rtmutex.c +121 -30
275 lines not on this page · raw message
kernel/locking/rtmutex_common.h +11 -11
@@ -40,13 +40,13 @@ extern void schedule_rt_mutex_test(struc* This is the control structure for tasks blocked on a rt_mutex, * which is allocated on the kernel stack on of the blocked task. * -* @list_entry: pi node to enqueue into the mutex waiters list -* @pi_list_entry: pi node to enqueue into the mutex owner waiters list +* @tree_entry: pi node to enqueue into the mutex waiters tree +* @pi_tree_entry: pi node to enqueue into the mutex owner waiters tree * @task: task reference to the blocked task */ struct rt_mutex_waiter { -struct plist_node list_entry; -struct plist_node pi_list_entry; +struct rb_node tree_entry; +struct rb_node pi_tree_entry;struct task_struct *task;struct rt_mutex *lock;#ifdef CONFIG_DEBUG_RT_MUTEXES
@@ -57,11 +57,11 @@ struct rt_mutex_waiter { };/* -* Various helpers to access the waiters-plist: +* Various helpers to access the waiters-tree: */ static inline int rt_mutex_has_waiters (struct rt_mutex *lock) { -return !plist_head_empty (&lock->wait_list); +return !RB_EMPTY_ROOT (&lock->waiters); } static inline struct rt_mutex_waiter *
@@ -69,8 +69,8 @@ rt_mutex_top_waiter(struct rt_mutex *loc {struct rt_mutex_waiter *w; - w = plist_first_entry(&lock->wait_list, struct rt_mutex_waiter, - list_entry); + w = rb_entry(lock->waiters_leftmost, struct rt_mutex_waiter, + tree_entry);BUG_ON (w->lock != lock);return w;
@@ -78,14 +78,14 @@ rt_mutex_top_waiter(struct rt_mutex *locstatic inline int task_has_pi_waiters (struct task_struct *p) { -return !plist_head_empty (&p->pi_waiters); +return !RB_EMPTY_ROOT (&p->pi_waiters); }static inline struct rt_mutex_waiter *task_top_pi_waiter (struct task_struct *p) { - return plist_first_entry(&p->pi_waiters, struct rt_mutex_waiter, - pi_list_entry); + return rb_entry(p->pi_waiters_leftmost, struct rt_mutex_waiter, + pi_tree_entry); }/*
kernel/sched/core.c +0 -4
@@ -6625,10 +6625,6 @@ void __init sched_init(void)INIT_HLIST_HEAD (&init_task.preempt_notifiers);#endif -#ifdef CONFIG_RT_MUTEXES -plist_head_init (&init_task.pi_waiters); -#endif -/* * The boot idle thread does lazy MMU switching as well: */
Peter Zijlstra
maintainerPATCH 7/13 sched: Add latency tracing for -deadline tasks
In reply to Peter ZijlstraFrom: Dario Faggioli <[email protected]>
It is very likely that systems that wants/needs to use the new SCHED_DEADLINE policy also want to have the scheduling latency of the -deadline tasks under control.
For this reason a new version of the scheduling wakeup latency, called "wakeup_dl", is introduced.
As a consequence of applying this patch there will be three wakeup latency tracer:
* "wakeup", that deals with all tasks in the system;
* "wakeup_rt", that deals with -rt and -deadline tasks only;
* "wakeup_dl", that deals with -deadline tasks only.
--- kernel/trace/trace_sched_wakeup.c | 64 ++++++++++++++++++++++++++++++++++--- kernel/trace/trace_selftest.c | 32 +++++++++++-------- 2 files changed, 78 insertions(+), 18 deletions(-)
kernel/trace/trace_sched_wakeup.c +60 -4
@@ -27,6 +27,8 @@ static int wakeup_cpu;static int wakeup_current_cpu;static unsigned wakeup_prio =-1 ;static int wakeup_rt; +static int wakeup_dl; +static int tracing_dl =0 ;static arch_spinlock_t wakeup_lock = (arch_spinlock_t )__ARCH_SPIN_LOCK_UNLOCKED;
@@ -437,6 +439,7 @@ static void __wakeup_reset(struct trace_array *tr) { wakeup_cpu =-1 ; wakeup_prio =-1 ; + tracing_dl =0 ;if (wakeup_task)put_task_struct (wakeup_task);
@@ -472,9 +475,17 @@ probe_wakeup(void *ignore, struct task_struct *p, int success)tracing_record_cmdline (p);tracing_record_cmdline (current); -if ((wakeup_rt && !rt_task (p)) || - p->prio >= wakeup_prio || - p->prio >= current->prio) +/* +* Semantic is like this: +* - wakeup tracer handles all tasks in the system, independently +* from their scheduling class; +* - wakeup_rt tracer handles tasks belonging to sched_dl and +* sched_rt class; +* - wakeup_dl handles tasks belonging to sched_dl class only. +*/ +if (tracing_dl || (wakeup_dl && !dl_task (p)) || + (wakeup_rt && !dl_task (p) && !rt_task (p)) || + (!dl_task (p) && (p->prio >= wakeup_prio || p->prio >= current->prio)))return ; pc =preempt_count ();
@@ -486,7 +497,8 @@ probe_wakeup(void *ignore, struct task_struct *p, int success)arch_spin_lock (&wakeup_lock);/* check for races. */ -if (!tracer_enabled || p->prio >= wakeup_prio) +if (!tracer_enabled || tracing_dl || + (!dl_task (p) && p->prio >= wakeup_prio)) goto out_locked;/* reset the trace */
@@ -496,6 +508,15 @@ probe_wakeup(void *ignore, struct task_struct *p, int success) wakeup_current_cpu = wakeup_cpu; wakeup_prio = p->prio; +/* +* Once you start tracing a -deadline task, don't bother tracing +* another task until the first one wakes up. +*/ +if (dl_task (p)) + tracing_dl =1 ; +else + tracing_dl =0 ; + wakeup_task = p;get_task_struct (wakeup_task);
@@ -597,16 +618,25 @@ static int __wakeup_tracer_init(struct trace_array *tr)static int wakeup_tracer_init (struct trace_array *tr) { + wakeup_dl =0 ; wakeup_rt =0 ;return __wakeup_tracer_init (tr); }static int wakeup_rt_tracer_init (struct trace_array *tr) { + wakeup_dl =0 ; wakeup_rt =1 ;return __wakeup_tracer_init (tr); } +static int wakeup_dl_tracer_init (struct trace_array *tr) +{ + wakeup_dl =1 ; + wakeup_rt =0 ; +return __wakeup_tracer_init (tr); +} +static void wakeup_tracer_reset (struct trace_array *tr) {int lat_flag = save_flags &TRACE_ITER_LATENCY_FMT ;
@@ -674,6 +704,28 @@ static struct tracer wakeup_rt_tracer __read_mostly = .use_max_tr = true, }; +static struct tracer wakeup_dl_tracer__read_mostly = +{ + .name ="wakeup_dl" , + .init = wakeup_dl_tracer_init, + .reset = wakeup_tracer_reset, + .start = wakeup_tracer_start, + .stop = wakeup_tracer_stop, + .wait_pipe = poll_wait_pipe, + .print_max = true, + .print_header = wakeup_print_header, + .print_line = wakeup_print_line, + .flags = &tracer_flags, + .set_flag = wakeup_set_flag, + .flag_changed = wakeup_flag_changed, +#ifdef CONFIG_FTRACE_SELFTEST + .selftest = trace_selftest_startup_wakeup, +#endif + .open = wakeup_trace_open, + .close = wakeup_trace_close, + .use_max_tr = true, +}; +__init static int init_wakeup_tracer (void ) {int ret;
@@ -686,6 +738,10 @@ __init static int init_wakeup_tracer(void)if (ret)return ret; + ret =register_tracer (&wakeup_dl_tracer); +if (ret) +return ret; +return 0 ; }core_initcall (init_wakeup_tracer);
kernel/trace/trace_selftest.c +18 -14
@@ -1022,11 +1022,15 @@ trace_selftest_startup_nop(struct tracer *trace, struct trace_array *tr)#ifdef CONFIG_SCHED_TRACER static int trace_wakeup_test_thread (void *data) { -/* Make this a RT thread, doesn't need to be too high */ -static const struct sched_param param = { .sched_priority =5 }; +/* Make this a -deadline thread */ +static const struct sched_attr attr = { + .sched_runtime =100000ULL , + .sched_deadline =10000000ULL , + .sched_period =10000000ULL + };struct completion *x = data; -sched_setscheduler (current,SCHED_FIFO , ¶m); +sched_setscheduler2 (current,SCHED_DEADLINE , &attr);/* Make it know we have a new prio */ complete (x);
@@ -1040,8 +1044,8 @@ static int trace_wakeup_test_thread(void *data)/* we are awake, now wait to disappear */ while (!kthread_should_stop ()) {/* -* This is an RT task, do short sleeps to let -* others run. +* This will likely be the system top priority +* task, do short sleeps to let others run. */ msleep (100 ); }
@@ -1054,21 +1058,21 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr) {unsigned long save_max = tracing_max_latency;struct task_struct *p; -struct completion isrt; +struct completion is_ready;unsigned long count;int ret; -init_completion (&isrt); +init_completion (&is_ready); -/* create a high prio thread */ - p =kthread_run (trace_wakeup_test_thread, &isrt,"ftrace-test" ); +/* create a -deadline thread */ + p =kthread_run (trace_wakeup_test_thread, &is_ready,"ftrace-test" );if (IS_ERR (p)) {printk (KERN_CONT "Failed to create ftrace wakeup test thread " );return -1 ; } -/* make sure the thread is running at an RT prio */ -wait_for_completion (&isrt); +/* make sure the thread is running at -deadline policy */ +wait_for_completion (&is_ready);/* start the tracing */ ret =tracer_init (trace, tr);
@@ -1082,19 +1086,19 @@ trace_selftest_startup_wakeup(struct tracer *trace, struct trace_array *tr)while (p->on_rq) {/* -* Sleep to make sure the RT thread is asleep too. +* Sleep to make sure the -deadline thread is asleep too. * On virtual machines we can't rely on timings, * but we want to make sure this test still works. */ msleep (100 ); } -init_completion (&isrt); +init_completion (&is_ready);wake_up_process (p);/* Wait for the task to wake up */ -wait_for_completion (&isrt); +wait_for_completion (&is_ready);/* stop the tracing. */ tracing_stop ();
Signature · 1 line
1.7.10.4
Peter Zijlstra
maintainerPATCH 8/13 sched: Drafted deadline inheritance logic
In reply to Peter ZijlstraFrom: Dario Faggioli <[email protected]>
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! :-)
--- include/linux/sched.h | 8 ++- include/linux/sched/rt.h | 1 kernel/fork.c | 1 kernel/locking/rtmutex.c | 31 +++++++++--- kernel/locking/rtmutex_common.h | 1 kernel/sched/core.c | 36 ++++++++++++--- kernel/sched/deadline.c | 91 ++++++++++++++++++++++---------------- kernel/sched/sched.h | 14 +++++ kernel/trace/trace_sched_wakeup.c | 1 9 files changed, 130 insertions(+), 54 deletions(-)
include/linux/sched.h +7 -1
@@ -1116,8 +1116,12 @@ struct sched_dl_entity {* @dl_new tells if a new instance arrived. If so we must * start executing it with full runtime and reset its absolute * deadline; +* +* @dl_boosted tells if we are boosted due to DI. If so we are +* outside bandwidth enforcement mechanism (but only until we +* exit the critical section). */ -int dl_throttled, dl_new; +int dl_throttled, dl_new, dl_boosted;/* * Bandwidth enforcement timer. Each -deadline task has its
@@ -1351,6 +1355,8 @@ struct task_struct {struct rb_node *pi_waiters_leftmost;/* Deadlock detection and priority inheritance handling */ struct rt_mutex_waiter *pi_blocked_on; +/* Top pi_waiters task */ +struct task_struct *pi_top_task;#endif #ifdef CONFIG_DEBUG_MUTEXES
include/linux/sched/rt.h +1 -0
@@ -35,6 +35,7 @@ static inline int rt_task(struct task_st#ifdef CONFIG_RT_MUTEXES extern int rt_mutex_getprio (struct task_struct *p);extern void rt_mutex_setprio (struct task_struct *p,int prio); +extern struct task_struct *rt_mutex_get_top_task (struct task_struct *task);extern void rt_mutex_adjust_pi (struct task_struct *p);static inline bool tsk_is_pi_blocked (struct task_struct *tsk) {
kernel/fork.c +1 -0
@@ -1089,6 +1089,7 @@ static void rt_mutex_init_task(struct ta p->pi_waiters =RB_ROOT ; p->pi_waiters_leftmost =NULL ; p->pi_blocked_on =NULL ; + p->pi_top_task =NULL ;#endif }
kernel/locking/rtmutex.c +22 -9
@@ -96,13 +96,16 @@ static inline int rt_mutex_waiter_less(struct rt_mutex_waiter *left, struct rt_mutex_waiter *right) { -if (left->task->prio < right->task->prio) +if (left->prio < right->prio)return 1 ;/* -* If both tasks are dl_task(), we check their deadlines. +* If both waiters have dl_prio(), we check the deadlines of the +* associated tasks. +* If left waiter has a dl_prio(), and we didn't return 1 above, +* then right waiter has a dl_prio() too. */ -if (dl_prio (left->task->prio) &&dl_prio (right->task->prio)) +if (dl_prio (left->prio))return (left->task->dl.deadline < right->task->dl.deadline);return 0 ;
@@ -197,10 +200,18 @@ int rt_mutex_getprio(struct task_structif (likely (!task_has_pi_waiters (task)))return task->normal_prio; -return min (task_top_pi_waiter (task)->task->prio, +return min (task_top_pi_waiter (task)->prio, task->normal_prio); } +struct task_struct *rt_mutex_get_top_task (struct task_struct *task) +{ +if (likely (!task_has_pi_waiters (task))) +return NULL ; + +return task_top_pi_waiter (task)->task; +} +/* * Adjust the priority of a task, after its pi_waiters got modified. *
@@ -210,7 +221,7 @@ static void __rt_mutex_adjust_prio(struc {int prio =rt_mutex_getprio (task); -if (task->prio != prio) +if (task->prio != prio ||dl_prio (prio))rt_mutex_setprio (task, prio); }
@@ -328,7 +339,7 @@ static int rt_mutex_adjust_prio_chain(st* When deadlock detection is off then we check, if further * priority adjustment is necessary. */ -if (!detect_deadlock && waiter->task->prio == task->prio) +if (!detect_deadlock && waiter->prio == task->prio) goto out_unlock_pi; lock = waiter->lock;
@@ -350,7 +361,7 @@ static int rt_mutex_adjust_prio_chain(st/* Requeue the waiter */ rt_mutex_dequeue (lock, waiter); - waiter->task->prio = task->prio; + waiter->prio = task->prio;rt_mutex_enqueue (lock, waiter);/* Release the task */
@@ -448,7 +459,7 @@ static int try_to_take_rt_mutex(struct r* 3) it is top waiter */ if (rt_mutex_has_waiters (lock)) { -if (task->prio >=rt_mutex_top_waiter (lock)->task->prio) { +if (task->prio >=rt_mutex_top_waiter (lock)->prio) {if (!waiter || waiter !=rt_mutex_top_waiter (lock))return 0 ; }
@@ -508,6 +519,7 @@ static int task_blocks_on_rt_mutex(struc__rt_mutex_adjust_prio (task); waiter->task = task; waiter->lock = lock; + waiter->prio = task->prio;/* Get the top priority waiter on the lock */ if (rt_mutex_has_waiters (lock))
@@ -653,7 +665,8 @@ void rt_mutex_adjust_pi(struct task_struraw_spin_lock_irqsave (&task->pi_lock, flags); waiter = task->pi_blocked_on; -if (!waiter || waiter->task->prio == task->prio) { +if (!waiter || (waiter->prio == task->prio && + !dl_prio (task->prio))) {raw_spin_unlock_irqrestore (&task->pi_lock, flags);return ; }
kernel/locking/rtmutex_common.h +1 -0
@@ -54,6 +54,7 @@ struct rt_mutex_waiter {struct pid *deadlock_task_pid;struct rt_mutex *deadlock_lock;#endif +int prio; };/*
kernel/sched/core.c +30 -6
@@ -947,7 +947,7 @@ static inline void check_class_changed(sif (prev_class->switched_from) prev_class->switched_from (rq, p); p->sched_class->switched_to (rq, p); - }else if (oldprio != p->prio) + }else if (oldprio != p->prio ||dl_task (p)) p->sched_class->prio_changed (rq, p, oldprio); }
@@ -2780,7 +2780,7 @@ EXPORT_SYMBOL(sleep_on_timeout);*/ void rt_mutex_setprio (struct task_struct *p,int prio) { -int oldprio, on_rq, running; +int oldprio, on_rq, running, enqueue_flag =0 ;struct rq *rq;const struct sched_class *prev_class;
@@ -2807,6 +2807,7 @@ void rt_mutex_setprio(struct task_struct }trace_sched_pi_setprio (p, prio); + p->pi_top_task =rt_mutex_get_top_task (p); oldprio = p->prio; prev_class = p->sched_class; on_rq = p->on_rq;
@@ -2816,19 +2817,42 @@ void rt_mutex_setprio(struct task_structif (running) p->sched_class->put_prev_task (rq, p); -if (dl_prio (prio)) +/* +* Boosting condition are: +* 1. -rt task is running and holds mutex A +* --> -dl task blocks on mutex A +* +* 2. -dl task is running and holds mutex A +* --> -dl task blocks on mutex A and could preempt the +* running task +*/ +if (dl_prio (prio)) { +if (!dl_prio (p->normal_prio) || (p->pi_top_task && +dl_entity_preempt (&p->pi_top_task->dl, &p->dl))) { + p->dl.dl_boosted =1 ; + p->dl.dl_throttled =0 ; + enqueue_flag =ENQUEUE_REPLENISH ; + }else + p->dl.dl_boosted =0 ; p->sched_class = &dl_sched_class; -else if (rt_prio (prio)) + }else if (rt_prio (prio)) { +if (dl_prio (oldprio)) + p->dl.dl_boosted =0 ; +if (oldprio < prio) + enqueue_flag =ENQUEUE_HEAD ; p->sched_class = &rt_sched_class; -else + }else { +if (dl_prio (oldprio)) + p->dl.dl_boosted =0 ; p->sched_class = &fair_sched_class; + } p->prio = prio;if (running) p->sched_class->set_curr_task (rq);if (on_rq) -enqueue_task (rq, p, oldprio < prio ?ENQUEUE_HEAD :0 ); +enqueue_task (rq, p, enqueue_flag);check_class_changed (rq, p, prev_class, oldprio); out_unlock:
kernel/sched/deadline.c +53 -38
208 lines not on this page · raw message
kernel/sched/sched.h +14 -0
@@ -106,6 +106,20 @@ static inline int task_has_dl_policy(strreturn dl_policy (p->policy); } +static inline int dl_time_before (u64 a,u64 b) +{ +return (s64)(a - b) <0 ; +} + +/* +* Tells if entity @a should preempt entity @b. +*/ +static inline +int dl_entity_preempt (struct sched_dl_entity *a,struct sched_dl_entity *b) +{ +return dl_time_before (a->deadline, b->deadline); +} +/* * This is the priority-queue data structure of the RT scheduling class: */
kernel/trace/trace_sched_wakeup.c +1 -0
@@ -16,6 +16,7 @@#include <linux/uaccess.h> #include <linux/ftrace.h> #include <linux/sched/rt.h> +#include <linux/sched/deadline.h> #include <trace/events/sched.h> #include "trace.h"
Peter Zijlstra
maintainerPATCH 9/13 sched: Add bandwidth management for sched_dl
In reply to Peter ZijlstraFrom: Dario Faggioli <[email protected]>
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.
--- include/linux/sched.h | 1 include/linux/sched/sysctl.h | 13 + kernel/sched/core.c | 437 ++++++++++++++++++++++++++++++++++++++++--- kernel/sched/deadline.c | 46 +++- kernel/sched/sched.h | 76 +++++++ kernel/sysctl.c | 14 + 6 files changed, 554 insertions(+), 33 deletions(-)
include/linux/sched.h +1 -0
@@ -1096,6 +1096,7 @@ struct sched_dl_entity {u64 dl_runtime;/* maximum runtime for each instance */ u64 dl_deadline;/* relative deadline of each instance */ u64 dl_period;/* separation of two instances (period) */ +u64 dl_bw;/* dl_runtime / dl_deadline */ /* * Actual scheduling parameters. Initialized with the values above,
include/linux/sched/sysctl.h +13 -0
@@ -81,6 +81,15 @@ static inline unsigned int get_sysctl_tiextern unsigned int sysctl_sched_rt_period;extern int sysctl_sched_rt_runtime; +/* +* control SCHED_DEADLINE reservations: +* +* /proc/sys/kernel/sched_dl_period_us +* /proc/sys/kernel/sched_dl_runtime_us +*/ +extern unsigned int sysctl_sched_dl_period; +extern int sysctl_sched_dl_runtime; +#ifdef CONFIG_CFS_BANDWIDTH extern unsigned int sysctl_sched_cfs_bandwidth_slice;#endif
@@ -99,4 +108,8 @@ extern int sched_rt_handler(struct ctl_t void __user *buffer, size_t *lenp, loff_t *ppos); +int sched_dl_handler (struct ctl_table *table,int write, +void __user *buffer,size_t *lenp, +loff_t *ppos); +#endif /* _SCHED_SYSCTL_H */
kernel/sched/core.c +413 -24
566 lines not on this page · raw message
kernel/sched/deadline.c +40 -6
94 lines not on this page · raw message
kernel/sched/sched.h +73 -3
133 lines not on this page · raw message
kernel/sysctl.c +14 -0
@@ -414,6 +414,20 @@ static struct ctl_table kern_table[] = { .mode = 0644, .proc_handler = sched_rr_handler, }, + { + .procname = "sched_dl_period_us", + .data = &sysctl_sched_dl_period, + .maxlen = sizeof(unsigned int), + .mode = 0644, + .proc_handler = sched_dl_handler, + }, + { + .procname = "sched_dl_runtime_us", + .data = &sysctl_sched_dl_runtime, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = sched_dl_handler, + }, #ifdef CONFIG_SCHED_AUTOGROUP { .procname = "sched_autogroup_enabled",
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 4 lines · Peter Zijlstra
kernel/sched/core.c +0
-0@@ -4381,6 +4592,13 @@ static int __migrate_task(struct task_st goto fail;/*
kernel/sched/core.c static int __migrate_task(struct task_st · line 4604
Quoted 10 lines
kernel/sched/core.c +7
-0+* If p is -deadline, proceed only if there is enough +* bandwidth available on dest_cpu +*/ +if (unlikely (dl_task (p)) && !set_task_cpu_dl (p, dest_cpu)) + goto fail; + +/* * If we're not on a rq, the next wake-up will ensure we're * placed properly. */
I just noticed this one.. we can't do this.
The reason we cannot do this is because:
CPU_DYING -> migration_call() -> migrate_tasks() -> __migrate_task()
cannot fail and hard assumes it _will_ move all tasks off of the dying cpu, failing this will break hotplug.
Also, I'm not entirely sure why this hunk exists. For GEDF we don't need this constraints AFAIK, as long as we guarantee we run the N earliest deadlines, it only matters what the total utilization (root domain wide) is, the per-cpu utilization is irrelevant.
If the purpose is to fail hotplug because taking out the CPU would end up in over-subscription, then we need a DOWN_PREPARE handler.
Dario, Juri?
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 2 lines · Peter Zijlstra
If the purpose is to fail hotplug because taking out the CPU would end up in over-subscription, then we need a
DOWN_PREPAREhandler.
Juri just said (on IRC) that that was indeed the intended purpose.
---
Subject: sched, deadline: Fix hotplug admission control
From: Peter Zijlstra <[email protected]>
Date: Thu Dec 19 11:54:45 CET 2013
The current hotplug admission control is broken because:
CPU_DYING -> migration_call() -> migrate_tasks() -> __migrate_task()
cannot fail and hard assumes it _will_ move all tasks off of the dying cpu, failing this will break hotplug.
The much simpler solution is a DOWN_PREPARE handler that fails when removing one CPU gets us below the total allocated bandwidth.
--- kernel/sched/core.c | 68 ++++++++++++++++------------------------------------ 1 file changed, 21 insertions(+), 47 deletions(-)
kernel/sched/core.c +21 -47
@@ -1886,9 +1886,9 @@ inline struct dl_bw *dl_bw_of(int i) return &cpu_rq(i)->rd->dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) { -return cpumask_weight (rq->rd->span); +return cpumask_weight (cpu_rq (i)->rd->span); }#else inline struct dl_bw *dl_bw_of (int i)
@@ -1896,7 +1896,7 @@ inline struct dl_bw *dl_bw_of(int i)return &cpu_rq (i)->dl.dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) {return 1 ; }
@@ -1937,7 +1937,7 @@ static int dl_overflow(struct task_strucu64 period = attr->sched_period;u64 runtime = attr->sched_runtime;u64 new_bw =dl_policy (policy) ?to_ratio (period, runtime) :0 ; -int cpus =__dl_span_weight (task_rq (p)); +int cpus =dl_bw_cpus (task_cpu (p));int err =-1 ;if (new_bw == p->dl.dl_bw)
@@ -4523,42 +4523,6 @@ int set_cpus_allowed_ptr(struct task_strEXPORT_SYMBOL_GPL (set_cpus_allowed_ptr);/* -* When dealing with a -deadline task, we have to check if moving it to -* a new CPU is possible or not. In fact, this is only true iff there -* is enough bandwidth available on such CPU, otherwise we want the -* whole migration procedure to fail over. -*/ -static inline -bool set_task_cpu_dl (struct task_struct *p,unsigned int cpu) -{ -struct dl_bw *dl_b =dl_bw_of (task_cpu (p)); -struct dl_bw *cpu_b =dl_bw_of (cpu); -int ret =1 ; -u64 bw; - -if (dl_b == cpu_b) -return 1 ; - -raw_spin_lock (&dl_b->lock); -raw_spin_lock (&cpu_b->lock); - - bw = cpu_b->bw *cpumask_weight (cpu_rq (cpu)->rd->span); -if (dl_bandwidth_enabled () && - bw < cpu_b->total_bw + p->dl.dl_bw) { - ret =0 ; - goto unlock; - } - dl_b->total_bw -= p->dl.dl_bw; - cpu_b->total_bw += p->dl.dl_bw; - -unlock: -raw_spin_unlock (&cpu_b->lock); -raw_spin_unlock (&dl_b->lock); - -return ret; -} - -/* * Move (not current) task off this cpu, onto dest cpu. We're doing * this because either it can't run here any more (set_cpus_allowed() * away from this CPU, or CPU going down), or because we're
@@ -4590,13 +4554,6 @@ static int __migrate_task(struct task_st goto fail;/* -* If p is -deadline, proceed only if there is enough -* bandwidth available on dest_cpu -*/ -if (unlikely (dl_task (p)) && !set_task_cpu_dl (p, dest_cpu)) - goto fail; - -/* * If we're not on a rq, the next wake-up will ensure we're * placed properly. */
@@ -4985,6 +4942,23 @@ migration_call(struct notifier_block *nfunsigned long flags;struct rq *rq =cpu_rq (cpu); +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ + { +struct dl_bw *dl_b =dl_bw_of (cpu); +int cpus =dl_bw_cpus (cpu); +bool overflow; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + overflow =__dl_overflow (dl_b, cpus-1 ,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY ); + } +break ; + } +switch (action & ~CPU_TASKS_FROZEN ) {case CPU_UP_PREPARE :
Steven Rostedt
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 7 lines · On Fri, 20 Dec 2013 18:13:43 +0100 Peter Zijlstra <[email protected]> wrote:
kernel/sched/core.c +3
-0@@ -4985,6 +4942,23 @@ migration_call(struct notifier_block *nfunsigned long flags;struct rq *rq =cpu_rq (cpu); +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ + {
kernel/sched/core.c migration_call(struct notifier_block *nf · line 4957
Quoted 10 lines
kernel/sched/core.c +10
-0+struct dl_bw *dl_b =dl_bw_of (cpu); +int cpus =dl_bw_cpus (cpu); +bool overflow; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + overflow =__dl_overflow (dl_b, cpus-1 ,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY );
Is it possible to have a race here to create a new deadline task that may work with cpus but not cpus-1? That is, if a new deadline task is currently being created as a CPU is going offline, this check happens first while the creation is spinning on the dl_b->lock, and it sets overflow to false, then once the lock is released, the new deadline task makes the condition true.
Should the system call have a get_online_cpus() somewhere?
-- Steve
Quoted 7 lines
kernel/sched/core.c +4
-0+ } +break ; + } +switch (action & ~CPU_TASKS_FROZEN ) {case CPU_UP_PREPARE :
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 29 lines · Steven Rostedt
Quoted 7 lines · On Fri, 20 Dec 2013 18:13:43 +0100 Peter Zijlstra <[email protected]> wrote:
kernel/sched/core.c +3
-0@@ -4985,6 +4942,23 @@ migration_call(struct notifier_block *nfunsigned long flags;struct rq *rq =cpu_rq (cpu); +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ + {kernel/sched/core.c migration_call(struct notifier_block *nf · line 4957
Quoted 10 lines
kernel/sched/core.c +10
-0+struct dl_bw *dl_b =dl_bw_of (cpu); +int cpus =dl_bw_cpus (cpu); +bool overflow; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + overflow =__dl_overflow (dl_b, cpus-1 ,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY );Is it possible to have a race here to create a new deadline task that may work with cpus but not cpus-1? That is, if a new deadline task is currently being created as a CPU is going offline, this check happens first while the creation is spinning on the
dl_b->lock, and it sets overflow to false, then once the lock is released, the new deadline task makes the condition true.
Quoted 1 line
Should the system call have a
get_online_cpus()somewhere?
No, should be all good; the entire admission control is serialized by that dl_b->lock, and its a raw_spin_lock (as can be seen from the above) which already very much excludes hotplug.
Steven Rostedt
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 30 lines · On Fri, 20 Dec 2013 18:42:00 +0100 Peter Zijlstra <[email protected]> wrote:
Quoted 29 lines · Steven Rostedt
Quoted 7 lines · On Fri, 20 Dec 2013 18:13:43 +0100 Peter Zijlstra <[email protected]> wrote:
kernel/sched/core.c +3
-0@@ -4985,6 +4942,23 @@ migration_call(struct notifier_block *nfunsigned long flags;struct rq *rq =cpu_rq (cpu); +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ + {kernel/sched/core.c migration_call(struct notifier_block *nf · line 4957
Quoted 10 lines
kernel/sched/core.c +10
-0+struct dl_bw *dl_b =dl_bw_of (cpu); +int cpus =dl_bw_cpus (cpu); +bool overflow; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + overflow =__dl_overflow (dl_b, cpus-1 ,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY );Is it possible to have a race here to create a new deadline task that may work with cpus but not cpus-1? That is, if a new deadline task is currently being created as a CPU is going offline, this check happens first while the creation is spinning on the
dl_b->lock, and it sets overflow to false, then once the lock is released, the new deadline task makes the condition true.
Quoted 5 lines
Quoted 1 line
Should the system call have a
get_online_cpus()somewhere?No, should be all good; the entire admission control is serialized by that
dl_b->lock, and its araw_spin_lock(as can be seen from the above) which already very much excludes hotplug.
I'm saying what stops this?
CPU 0 CPU 1 ----- -----
sched_setattr()
dl_overflow()
cpus = __dl_span_weight()
cpu_down() raw_spin_lock()
raw_spin_lock() /* blocks */
overflow = __dl_overflow(cpus-1); raw_spin_unlock();
/* gets lock */
__dl_overflow(cpus) /* all OK! */
/* cpus goes to cpus - 1 making __dl_overflow() not OK anymore */
-- Steve
Steven Rostedt
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 9 lines · On Fri, 20 Dec 2013 13:23:23 -0500 Steven Rostedt <[email protected]> wrote:
CPU 0 CPU 1 ----- -----
sched_setattr()
dl_overflow()
cpus =__dl_span_weight()cpu_down() raw_spin_lock()
Quoted 8 lines
raw_spin_lock()/* blocks */overflow = __dl_overflow(cpus-1); raw_spin_unlock();/* gets lock */
__dl_overflow(cpus)/* all OK! */
Forgot to add:
/* new deadline commitment added here */
Quoted 6 lines
/* cpus goes to cpus - 1 making __dl_overflow() not OK anymore */
also should have stated:
"__dl_overflow(cpus-1) not OK anymore"
-- Steve
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
In reply to Steven RostedtQuoted 1 line · Steven Rostedt
I'm saying what stops this?
oh duh, yes.
So the below is a bit cumbersome in having to use rd->span & cpu_active_mask because it appears rd->online is too late again.
So I think this will avoid the problem by being consistent with the cpu count. At worst it will reject a new task that could've fit, but that's a safe mistake to make.
kernel/sched/core.c +32 -52
@@ -1886,9 +1886,15 @@ inline struct dl_bw *dl_bw_of(int i) return &cpu_rq(i)->rd->dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) { -return cpumask_weight (rq->rd->span); +struct root_domain *rd =cpu_rq (i)->rd; +int cpus =0 ; + +for_each_cpu_and (rd->span, cpu_active_mask) + cpus++; + +return cpus; }#else inline struct dl_bw *dl_bw_of (int i)
@@ -1896,7 +1902,7 @@ inline struct dl_bw *dl_bw_of(int i)return &cpu_rq (i)->dl.dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) {return 1 ; }
@@ -1937,8 +1943,7 @@ static int dl_overflow(struct task_strucu64 period = attr->sched_period;u64 runtime = attr->sched_runtime;u64 new_bw =dl_policy (policy) ?to_ratio (period, runtime) :0 ; -int cpus =__dl_span_weight (task_rq (p)); -int err =-1 ; +int cpus, err =-1 ;if (new_bw == p->dl.dl_bw)return 0 ;
@@ -1949,6 +1954,7 @@ static int dl_overflow(struct task_struc* allocated bandwidth of the container. */ raw_spin_lock (&dl_b->lock); + cpus =dl_bw_cpus (task_cpu (p));if (dl_policy (policy) && !task_has_dl_policy (p) && !__dl_overflow (dl_b, cpus,0 , new_bw)) {__dl_add (dl_b, new_bw);
@@ -4523,42 +4529,6 @@ int set_cpus_allowed_ptr(struct task_strEXPORT_SYMBOL_GPL (set_cpus_allowed_ptr);/* -* When dealing with a -deadline task, we have to check if moving it to -* a new CPU is possible or not. In fact, this is only true iff there -* is enough bandwidth available on such CPU, otherwise we want the -* whole migration procedure to fail over. -*/ -static inline -bool set_task_cpu_dl (struct task_struct *p,unsigned int cpu) -{ -struct dl_bw *dl_b =dl_bw_of (task_cpu (p)); -struct dl_bw *cpu_b =dl_bw_of (cpu); -int ret =1 ; -u64 bw; - -if (dl_b == cpu_b) -return 1 ; - -raw_spin_lock (&dl_b->lock); -raw_spin_lock (&cpu_b->lock); - - bw = cpu_b->bw *cpumask_weight (cpu_rq (cpu)->rd->span); -if (dl_bandwidth_enabled () && - bw < cpu_b->total_bw + p->dl.dl_bw) { - ret =0 ; - goto unlock; - } - dl_b->total_bw -= p->dl.dl_bw; - cpu_b->total_bw += p->dl.dl_bw; - -unlock: -raw_spin_unlock (&cpu_b->lock); -raw_spin_unlock (&dl_b->lock); - -return ret; -} - -/* * Move (not current) task off this cpu, onto dest cpu. We're doing * this because either it can't run here any more (set_cpus_allowed() * away from this CPU, or CPU going down), or because we're
@@ -4590,13 +4560,6 @@ static int __migrate_task(struct task_st goto fail;/* -* If p is -deadline, proceed only if there is enough -* bandwidth available on dest_cpu -*/ -if (unlikely (dl_task (p)) && !set_task_cpu_dl (p, dest_cpu)) - goto fail; - -/* * If we're not on a rq, the next wake-up will ensure we're * placed properly. */
@@ -4986,7 +4949,6 @@ migration_call(struct notifier_block *nfstruct rq *rq =cpu_rq (cpu);switch (action & ~CPU_TASKS_FROZEN ) { -case CPU_UP_PREPARE : rq->calc_load_update = calc_load_update;break ;
@@ -5056,10 +5018,28 @@ static int sched_cpu_inactive(struct notswitch (action & ~CPU_TASKS_FROZEN ) {case CPU_DOWN_PREPARE :set_cpu_active ((long )hcpu, false); -return NOTIFY_OK ; -default : -return NOTIFY_DONE ; +break ; } + +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ + { +struct dl_bw *dl_b =dl_bw_of (cpu); +bool overflow; +int cpus; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + cpus =dl_bw_cpus (cpu); + overflow =__dl_overflow (dl_b, cpus,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY ); + } +break ; + } + +return NOTIFY_OK ; }static int __init migration_init (void )
Steven Rostedt
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
kernel/sched/core.c static int sched_cpu_inactive(struct not · line 5025
Quoted 12 lines · On Fri, 20 Dec 2013 22:44:13 +0100 Peter Zijlstra <[email protected]> wrote:
kernel/sched/core.c +4
-3@@ -5056,10 +5018,28 @@ static int sched_cpu_inactive(struct notswitch (action & ~CPU_TASKS_FROZEN ) {case CPU_DOWN_PREPARE :set_cpu_active ((long )hcpu, false); -return NOTIFY_OK ; -default : -return NOTIFY_DONE ; +break ; } + +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */
Instead of the double switch (which is quite confusing), what about just adding:
if (!(action & CPU_TASKS_FROZEN))
I mean, the above switch gets called for both cases, this only gets called for the one case. This case is a subset of the above. I don't see why an if () would not be better than a double (confusing) switch().
Also, it seems that this change also does not return NOTIFY_DONE if something other than CPU_DOWN_PREPARE is passed in.
-- Steve
Quoted 20 lines
kernel/sched/core.c +17
-0+ { +struct dl_bw *dl_b =dl_bw_of (cpu); +bool overflow; +int cpus; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + cpus =dl_bw_cpus (cpu); + overflow =__dl_overflow (dl_b, cpus,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY ); + } +break ; + } + +return NOTIFY_OK ; }static int __init migration_init (void )
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Quoted 20 lines · Steven Rostedt
kernel/sched/core.c static int sched_cpu_inactive(struct not · line 5025
Quoted 12 lines · On Fri, 20 Dec 2013 22:44:13 +0100 Peter Zijlstra <[email protected]> wrote:
kernel/sched/core.c +4
-3@@ -5056,10 +5018,28 @@ static int sched_cpu_inactive(struct notswitch (action & ~CPU_TASKS_FROZEN ) {case CPU_DOWN_PREPARE :set_cpu_active ((long )hcpu, false); -return NOTIFY_OK ; -default : -return NOTIFY_DONE ; +break ; } + +switch (action) { +case CPU_DOWN_PREPARE :/* explicitly allow suspend */ Instead of the double switch (which is quite confusing), what about just adding:
Quoted 5 lines
if (!(action &
CPU_TASKS_FROZEN))I mean, the above switch gets called for both cases, this only gets called for the one case. This case is a subset of the above. I don't see why an if () would not be better than a double (confusing)
switch().
I don't see the confusion in the double switch(), but sure an if would work too I suppose.
Quoted 2 lines
Also, it seems that this change also does not return
NOTIFY_DONEif something other thanCPU_DOWN_PREPAREis passed in.
Yeah, I had a look but couldn't find an actual difference between NOTIFY_DONE and NOTIFY_OK. Maybe I missed it..
Peter Zijlstra
maintainerRe: [PATCH 09/13] sched: Add bandwidth management for sched_dl
Like this then? :-)
kernel/sched/core.c +17 -2
@@ -5056,10 +5019,25 @@ static int sched_cpu_inactive(struct notswitch (action & ~CPU_TASKS_FROZEN ) {case CPU_DOWN_PREPARE :set_cpu_active ((long )hcpu, false); + +/* explicitly allow suspend */ +if (!(action &CPU_TASKS_FROZEN )) { +struct dl_bw *dl_b =dl_bw_of (cpu); +bool overflow; +int cpus; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + cpus =dl_bw_cpus (cpu); + overflow =__dl_overflow (dl_b, cpus,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY ); + }return NOTIFY_OK ; -default : -return NOTIFY_DONE ; } + +return NOTIFY_DONE ; }static int __init migration_init (void )
tip-bot for Peter Zijlstra
merge bot[tip:sched/core] sched/deadline: Fix hotplug admission control
In reply to Peter Zijlstrasched/deadline: Fix hotplug admission control
Commit-ID: de212f18e92c952533d57c5510d2790199c75734 Gitweb: http://git.kernel.org/tip/de212f18e92c952533d57c5510d2790199c75734 Author: Peter Zijlstra <[email protected]> AuthorDate: Thu, 19 Dec 2013 11:54:45 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Mon, 13 Jan 2014 13:47:25 +0100
sched/deadline: Fix hotplug admission control
The current hotplug admission control is broken because:
CPU_DYING -> migration_call() -> migrate_tasks() -> __migrate_task()
cannot fail and hard assumes it _will_ move all tasks off of the dying cpu, failing this will break hotplug.
The much simpler solution is a DOWN_PREPARE handler that fails when removing one CPU gets us below the total allocated bandwidth.
--- kernel/sched/core.c | 83 +++++++++++++++++++++-------------------------------- 1 file changed, 32 insertions(+), 51 deletions(-)
kernel/sched/core.c +32 -51
@@ -1887,9 +1887,15 @@ inline struct dl_bw *dl_bw_of(int i) return &cpu_rq(i)->rd->dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) { -return cpumask_weight (rq->rd->span); +struct root_domain *rd =cpu_rq (i)->rd; +int cpus =0 ; + +for_each_cpu_and (i, rd->span, cpu_active_mask) + cpus++; + +return cpus; }#else inline struct dl_bw *dl_bw_of (int i)
@@ -1897,7 +1903,7 @@ inline struct dl_bw *dl_bw_of(int i)return &cpu_rq (i)->dl.dl_bw; } -static inline int __dl_span_weight (struct rq *rq) +static inline int dl_bw_cpus (int i) {return 1 ; }
@@ -1938,8 +1944,7 @@ static int dl_overflow(struct task_struct *p, int policy,u64 period = attr->sched_period;u64 runtime = attr->sched_runtime;u64 new_bw =dl_policy (policy) ?to_ratio (period, runtime) :0 ; -int cpus =__dl_span_weight (task_rq (p)); -int err =-1 ; +int cpus, err =-1 ;if (new_bw == p->dl.dl_bw)return 0 ;
@@ -1950,6 +1955,7 @@ static int dl_overflow(struct task_struct *p, int policy,* allocated bandwidth of the container. */ raw_spin_lock (&dl_b->lock); + cpus =dl_bw_cpus (task_cpu (p));if (dl_policy (policy) && !task_has_dl_policy (p) && !__dl_overflow (dl_b, cpus,0 , new_bw)) {__dl_add (dl_b, new_bw);
@@ -4522,42 +4528,6 @@ out:EXPORT_SYMBOL_GPL (set_cpus_allowed_ptr);/* -* When dealing with a -deadline task, we have to check if moving it to -* a new CPU is possible or not. In fact, this is only true iff there -* is enough bandwidth available on such CPU, otherwise we want the -* whole migration procedure to fail over. -*/ -static inline -bool set_task_cpu_dl (struct task_struct *p,unsigned int cpu) -{ -struct dl_bw *dl_b =dl_bw_of (task_cpu (p)); -struct dl_bw *cpu_b =dl_bw_of (cpu); -int ret =1 ; -u64 bw; - -if (dl_b == cpu_b) -return 1 ; - -raw_spin_lock (&dl_b->lock); -raw_spin_lock (&cpu_b->lock); - - bw = cpu_b->bw *cpumask_weight (cpu_rq (cpu)->rd->span); -if (dl_bandwidth_enabled () && - bw < cpu_b->total_bw + p->dl.dl_bw) { - ret =0 ; - goto unlock; - } - dl_b->total_bw -= p->dl.dl_bw; - cpu_b->total_bw += p->dl.dl_bw; - -unlock: -raw_spin_unlock (&cpu_b->lock); -raw_spin_unlock (&dl_b->lock); - -return ret; -} - -/* * Move (not current) task off this cpu, onto dest cpu. We're doing * this because either it can't run here any more (set_cpus_allowed() * away from this CPU, or CPU going down), or because we're
@@ -4589,13 +4559,6 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu) goto fail;/* -* If p is -deadline, proceed only if there is enough -* bandwidth available on dest_cpu -*/ -if (unlikely (dl_task (p)) && !set_task_cpu_dl (p, dest_cpu)) - goto fail; - -/* * If we're not on a rq, the next wake-up will ensure we're * placed properly. */
@@ -5052,13 +5015,31 @@ static int sched_cpu_active(struct notifier_block *nfb,static int sched_cpu_inactive (struct notifier_block *nfb,unsigned long action,void *hcpu) { +unsigned long flags; +long cpu = (long )hcpu; +switch (action & ~CPU_TASKS_FROZEN ) {case CPU_DOWN_PREPARE : -set_cpu_active ((long )hcpu, false); +set_cpu_active (cpu, false); + +/* explicitly allow suspend */ +if (!(action &CPU_TASKS_FROZEN )) { +struct dl_bw *dl_b =dl_bw_of (cpu); +bool overflow; +int cpus; + +raw_spin_lock_irqsave (&dl_b->lock, flags); + cpus =dl_bw_cpus (cpu); + overflow =__dl_overflow (dl_b, cpus,0 ,0 ); +raw_spin_unlock_irqrestore (&dl_b->lock, flags); + +if (overflow) +return notifier_from_errno (-EBUSY ); + }return NOTIFY_OK ; -default : -return NOTIFY_DONE ; } + +return NOTIFY_DONE ; }static int __init migration_init (void )
Peter Zijlstra
maintainerPATCH 10/13 sched: speed up -dl pushes with a push-heap.
In reply to Peter ZijlstraFrom: Juri Lelli <[email protected]>
Data from tests confirmed that the original active load balancing logic didn't scale neither in the number of CPU nor in the number of tasks (as sched_rt does).
Here we provide a global data structure to keep track of deadlines of the running tasks in the system. The structure is composed by a bitmask showing the free CPUs and a max-heap, needed when the system is heavily loaded.
The implementation and concurrent access scheme are kept simple by design. However, our measurements show that we can compete with sched_rt on large multi-CPUs machines [1].
Only the push path is addressed, the extension to use this structure also for pull decisions is straightforward. However, we are currently evaluating different (in order to decrease/avoid contention) data structures to solve possibly both problems. We are also going to re-run tests considering recent changes inside cpupri [2].
[1] http://retis.sssup.it/~jlelli/papers/Ospert11Lelli.pdf
[2] http://www.spinics.net/lists/linux-rt-users/msg06778.html
--- kernel/sched/Makefile | 2 +- kernel/sched/core.c | 3 + kernel/sched/cpudeadline.c | 216 ++++++++++++++++++++++++++++++++++++++++++++ kernel/sched/cpudeadline.h | 33 +++++++ kernel/sched/deadline.c | 53 +++-------- kernel/sched/sched.h | 2 + 6 files changed, 269 insertions(+), 40 deletions(-) create mode 100644 kernel/sched/cpudeadline.c create mode 100644 kernel/sched/cpudeadline.h
kernel/sched/Makefile +1 -1
@@ -14,7 +14,7 @@ endif obj-y += core.o proc.o clock.o cputime.o obj-y += idle_task.o fair.o rt.o deadline.o stop_task.o obj-y += wait.o completion.o -obj-$(CONFIG_SMP) += cpupri.o +obj-$(CONFIG_SMP) += cpupri.o cpudeadline.o obj-$(CONFIG_SCHED_AUTOGROUP) += auto_group.o obj-$(CONFIG_SCHEDSTATS) += stats.o obj-$(CONFIG_SCHED_DEBUG) += debug.o
kernel/sched/core.c +3 -0
@@ -5278,6 +5278,7 @@ static void free_rootdomain(struct rcu_head *rcu) struct root_domain *rd = container_of(rcu, struct root_domain, rcu);cpupri_cleanup (&rd->cpupri); +cpudl_cleanup (&rd->cpudl);free_cpumask_var (rd->dlo_mask);free_cpumask_var (rd->rto_mask);free_cpumask_var (rd->online);
@@ -5336,6 +5337,8 @@ static int init_rootdomain(struct root_domain *rd) goto free_dlo_mask;init_dl_bw (&rd->dl_bw); +if (cpudl_init (&rd->cpudl) !=0 ) + goto free_dlo_mask;if (cpupri_init (&rd->cpupri) !=0 ) goto free_rto_mask;
kernel/sched/cpudeadline.c new file +216 -0
216 lines not on this page · raw message
kernel/sched/cpudeadline.h new file +33 -0
@@ -0,0 +1,33 @@ +#ifndef _LINUX_CPUDL_H +#define _LINUX_CPUDL_H + +#include <linux/sched.h> + +#define IDX_INVALID -1 + +struct array_item { +u64 dl; +int cpu; +}; + +struct cpudl { +raw_spinlock_t lock; +int size; +int cpu_to_idx[NR_CPUS ]; +struct array_item elements[NR_CPUS ]; +cpumask_var_t free_cpus; +}; + + +#ifdef CONFIG_SMP +int cpudl_find (struct cpudl *cp,struct task_struct *p, +struct cpumask *later_mask); +void cpudl_set (struct cpudl *cp,int cpu,u64 dl,int is_valid); +int cpudl_init (struct cpudl *cp); +void cpudl_cleanup (struct cpudl *cp); +#else +#define cpudl_set (cp, cpu, dl) do { } while (0) +#define cpudl_init () do { } while (0) +#endif /* CONFIG_SMP */ + +#endif /* _LINUX_CPUDL_H */
kernel/sched/deadline.c +14 -39
119 lines not on this page · raw message
kernel/sched/sched.h +2 -0
@@ -10,6 +10,7 @@#include <linux/slab.h> #include "cpupri.h" +#include "cpudeadline.h" #include "cpuacct.h" struct rq ;
@@ -501,6 +502,7 @@ struct root_domain {cpumask_var_t dlo_mask;atomic_t dlo_count;struct dl_bw dl_bw; +struct cpudl cpudl;/* * The "RT overload" flag: it gets set if a CPU has more than
Signature · 1 line
1.7.10.4
Peter Zijlstra
maintainerPATCH 11/13 sched: Remove sched_setscheduler2()
In reply to Peter ZijlstraExpand sched_{set,get}attr() to include the policy and nice value.
This obviates the need for sched_setscheduler2().
The new sched_setattr() call now covers the functionality of:
sched_setscheduler(),
sched_setparam(),
setpriority(.which = PRIO_PROCESS)
And sched_getattr() now covers:
sched_getscheduler(),
sched_getparam(),
getpriority(.which = PRIO_PROCESS)
--- arch/arm/include/asm/unistd.h | 2 arch/arm/include/uapi/asm/unistd.h | 5 - arch/arm/kernel/calls.S | 3 arch/x86/syscalls/syscall_32.tbl | 1 arch/x86/syscalls/syscall_64.tbl | 1 include/linux/sched.h | 24 +++-- include/linux/syscalls.h | 2 kernel/sched/core.c | 173 +++++++++++++++++++------------------ kernel/sched/sched.h | 13 +- 9 files changed, 119 insertions(+), 105 deletions(-)
arch/arm/include/asm/unistd.h +1 -1
@@ -15,7 +15,7 @@#include <uapi/asm/unistd.h> -#define __NR_syscalls (383) +#define __NR_syscalls (382)#define __ARM_NR_cmpxchg (__ARM_NR_BASE+0x00fff0)#define __ARCH_WANT_STAT64
arch/arm/include/uapi/asm/unistd.h +2 -3
@@ -406,9 +406,8 @@#define __NR_process_vm_writev (__NR_SYSCALL_BASE+377)#define __NR_kcmp (__NR_SYSCALL_BASE+378)#define __NR_finit_module (__NR_SYSCALL_BASE+379) -#define __NR_sched_setscheduler2 (__NR_SYSCALL_BASE+380) -#define __NR_sched_setattr (__NR_SYSCALL_BASE+381) -#define __NR_sched_getattr (__NR_SYSCALL_BASE+382) +#define __NR_sched_setattr (__NR_SYSCALL_BASE+380) +#define __NR_sched_getattr (__NR_SYSCALL_BASE+381)/* * This may need to be greater than __NR_last_syscall+1 in order to
arch/arm/kernel/calls.S +1 -2
@@ -389,8 +389,7 @@ CALL(sys_process_vm_writev) CALL(sys_kcmp) CALL(sys_finit_module) -/* 380 */ CALL(sys_sched_setscheduler2) - CALL(sys_sched_setattr) +/* 380 */ CALL(sys_sched_setattr) CALL(sys_sched_getattr) #ifndef syscalls_counted .equ syscalls_padding, ((NR_syscalls + 3) & ~3) - NR_syscalls
arch/x86/syscalls/syscall_32.tbl +0 -1
@@ -359,4 +359,3 @@ 350 i386 finit_module sys_finit_module 351 i386 sched_setattr sys_sched_setattr 352 i386 sched_getattr sys_sched_getattr -353 i386 sched_setscheduler2 sys_sched_setscheduler2
arch/x86/syscalls/syscall_64.tbl +0 -1
@@ -322,7 +322,6 @@ 313 common finit_module sys_finit_module 314 common sched_setattr sys_sched_setattr 315 common sched_getattr sys_sched_getattr -316 common sched_setscheduler2 sys_sched_setscheduler2 # # x32-specific system call numbers start at 512 to avoid cache impact
include/linux/sched.h +16 -8
@@ -57,7 +57,7 @@ struct sched_param {#include <asm/processor.h> -#define SCHED_ATTR_SIZE_VER0 40/* sizeof first published struct */ +#define SCHED_ATTR_SIZE_VER0 48/* sizeof first published struct */ /* * Extended scheduling parameters data structure.
@@ -85,7 +85,9 @@ struct sched_param {* * This is reflected by the actual fields of the sched_attr structure: * -* @sched_priority task's priority (might still be useful) +* @sched_policy task's scheduling policy +* @sched_nice task's nice value (SCHED_NORMAL/BATCH) +* @sched_priority task's static priority (SCHED_FIFO/RR) * @sched_flags for customizing the scheduler behaviour * @sched_deadline representative of the task's deadline * @sched_runtime representative of the task's runtime
@@ -102,15 +104,21 @@ struct sched_param {* available in the scheduling class file or in Documentation/. */ struct sched_attr { -int sched_priority; -unsigned int sched_flags; +u32 size; + +u32 sched_policy; +u64 sched_flags; + +/* SCHED_NORMAL, SCHED_BATCH */ +s32 sched_nice; + +/* SCHED_FIFO, SCHED_RR */ +u32 sched_priority; + +/* SCHED_DEADLINE */ u64 sched_runtime;u64 sched_deadline;u64 sched_period; -u32 size; - -/* Align to u64. */ -u32 __reserved; };struct exec_domain ;
include/linux/syscalls.h +0 -2
@@ -278,8 +278,6 @@ asmlinkage long sys_clock_nanosleep(clocasmlinkage long sys_nice (int increment);asmlinkage long sys_sched_setscheduler (pid_t pid,int policy,struct sched_param __user *param); -asmlinkage long sys_sched_setscheduler2 (pid_t pid,int policy, -struct sched_attr __user *attr);asmlinkage long sys_sched_setparam (pid_t pid,struct sched_param __user *param); asmlinkage long sys_sched_setattr(pid_t pid,
kernel/sched/core.c +92 -81
298 lines not on this page · raw message
kernel/sched/sched.h +7 -6
@@ -90,18 +90,19 @@ extern void update_cpu_load_active(struc*/ #define DL_SCALE (10) +static inline int fair_policy (int policy) +{ +return policy ==SCHED_NORMAL || policy ==SCHED_BATCH ; +} +static inline int rt_policy (int policy) { -if (policy ==SCHED_FIFO || policy ==SCHED_RR ) -return 1 ; -return 0 ; +return policy ==SCHED_FIFO || policy ==SCHED_RR ; }static inline int dl_policy (int policy) { -if (unlikely (policy ==SCHED_DEADLINE )) -return 1 ; -return 0 ; +return unlikely (policy ==SCHED_DEADLINE ); }static inline int task_has_rt_policy (struct task_struct *p)
Peter Zijlstra
maintainerPATCH 12/13 sched, deadline: Fixup the smp-affinity mask tests
In reply to Peter ZijlstraFor now deadline tasks are not allowed to set smp affinity; however the current tests are wrong, cure this.
The test in __sched_setscheduler() also uses an on-stack cpumask_t which is a no-no.
Change both tests to use cpumask_subset() such that we test the root domain span to be a subset of the cpus_allowed mask. This way we're sure the tasks can always run on all CPUs they can be balanced over, and have no effective affinity constraints.
--- kernel/sched/core.c | 44 +++++++++--------------------------- kernel/sched/rt.c | 62 +++++++++++++++++++++++++++++++++++++-------------- kernel/sched/sched.h | 2 + 3 files changed, 58 insertions(+), 50 deletions(-)
kernel/sched/core.c +9 -19
@@ -3384,23 +3384,14 @@ static int __sched_setscheduler(struct t#ifdef CONFIG_SMP if (dl_bandwidth_enabled () &&dl_policy (policy)) {cpumask_t *span = rq->rd->span; -cpumask_t act_affinity; - -/* -* cpus_allowed mask is statically initialized with -* CPU_MASK_ALL, span is instead dynamic. Here we -* compute the "dynamic" affinity of a task. -*/ -cpumask_and (&act_affinity, &p->cpus_allowed, - cpu_active_mask);/* * Don't allow tasks with an affinity mask smaller than * the entire root_domain to become SCHED_DEADLINE. We * will also fail if there's no bandwidth available. */ -if (!cpumask_equal (&act_affinity, span) || - rq->rd->dl_bw.bw ==0 ) { +if (!cpumask_subset (span, &p->cpus_allowed) || + rq->rd->dl_bw.bw ==0 ) {__task_rq_unlock (rq);raw_spin_unlock_irqrestore (&p->pi_lock, flags);return -EPERM ;
@@ -3421,8 +3412,7 @@ static int __sched_setscheduler(struct t* of a SCHED_DEADLINE task) we need to check if enough bandwidth * is available. */ -if ((dl_policy (policy) ||dl_task (p)) && -dl_overflow (p, policy, attr)) { +if ((dl_policy (policy) ||dl_task (p)) &&dl_overflow (p, policy, attr)) {task_rq_unlock (rq, p, &flags);return -EBUSY ; }
@@ -3861,6 +3851,10 @@ long sched_setaffinity(pid_t pid, constif (retval) goto out_unlock; + +cpuset_cpus_allowed (p, cpus_allowed); +cpumask_and (new_mask, in_mask, cpus_allowed); +/* * Since bandwidth control happens on root_domain basis, * if admission test is enabled, we only admit -deadline
@@ -3871,16 +3865,12 @@ long sched_setaffinity(pid_t pid, constif (task_has_dl_policy (p)) {const struct cpumask *span =task_rq (p)->rd->span; -if (dl_bandwidth_enabled () && - !cpumask_equal (in_mask, span)) { +if (dl_bandwidth_enabled () && !cpumask_subset (span, new_mask)) { retval = -EBUSY ; goto out_unlock; } }#endif - -cpuset_cpus_allowed (p, cpus_allowed); -cpumask_and (new_mask, in_mask, cpus_allowed); again: retval =set_cpus_allowed_ptr (p, new_mask);
@@ -4536,7 +4526,7 @@ EXPORT_SYMBOL_GPL(set_cpus_allowed_ptr);* When dealing with a -deadline task, we have to check if moving it to * a new CPU is possible or not. In fact, this is only true iff there * is enough bandwidth available on such CPU, otherwise we want the -* whole migration progedure to fail over. +* whole migration procedure to fail over. */ static inline bool set_task_cpu_dl (struct task_struct *p,unsigned int cpu)
Peter Zijlstra
maintainerPATCH 13/13 sched, deadline: Remove the sysctl_sched_dl knobs
In reply to Peter ZijlstraRemove the deadline specific sysctls for now. The problem with them is that the interaction with the exisiting rt knobs is nearly impossible to get right.
The current (as per before this patch) situation is that the rt and dl bandwidth is completely separate and we enforce rt+dl < 100%. This is undesirable because this means that the rt default of 95% leaves us hardly any room, even though dl tasks are saver than rt tasks.
Another proposed solution was (a discarted patch) to have the dl bandwidth be a fraction of the rt bandwidth. This is highly confusing imo.
Furthermore neither proposal is consistent with the situation we actually want; which is rt tasks ran from a dl server. In which case the rt bandwidth is a direct subset of dl.
So whichever way we go, the introduction of dl controls at this point is painful. Therefore remove them and instead share the rt budget.
This means that for now the rt knobs are used for dl admission control and the dl runtime is accounted against the rt runtime. I realise that this isn't entirely desirable either; but whatever we do we appear to need to change the interface later, so better have a small interface for now.
--- include/linux/sched/sysctl.h | 13 -- kernel/sched/core.c | 259 +++++++++++-------------------------------- kernel/sched/deadline.c | 27 ++++ kernel/sched/sched.h | 18 -- kernel/sysctl.c | 14 -- 5 files changed, 97 insertions(+), 234 deletions(-)
include/linux/sched/sysctl.h +0 -13
@@ -81,15 +81,6 @@ static inline unsigned int get_sysctl_tiextern unsigned int sysctl_sched_rt_period;extern int sysctl_sched_rt_runtime; -/* -* control SCHED_DEADLINE reservations: -* -* /proc/sys/kernel/sched_dl_period_us -* /proc/sys/kernel/sched_dl_runtime_us -*/ -extern unsigned int sysctl_sched_dl_period; -extern int sysctl_sched_dl_runtime; -#ifdef CONFIG_CFS_BANDWIDTH extern unsigned int sysctl_sched_cfs_bandwidth_slice;#endif
@@ -108,8 +99,4 @@ extern int sched_rt_handler(struct ctl_t void __user *buffer, size_t *lenp, loff_t *ppos); -int sched_dl_handler (struct ctl_table *table,int write, -void __user *buffer,size_t *lenp, -loff_t *ppos); -#endif /* _SCHED_SYSCTL_H */
kernel/sched/core.c +71 -188
347 lines not on this page · raw message
kernel/sched/deadline.c +25 -2
@@ -63,10 +63,10 @@ void init_dl_bw(struct dl_bw *dl_b) {raw_spin_lock_init (&dl_b->lock);raw_spin_lock (&def_dl_bandwidth.dl_runtime_lock); -if (global_dl_runtime () ==RUNTIME_INF ) +if (global_rt_runtime () ==RUNTIME_INF ) dl_b->bw =-1 ;else - dl_b->bw =to_ratio (global_dl_period (),global_dl_runtime ()); + dl_b->bw =to_ratio (global_rt_period (),global_rt_runtime ());raw_spin_unlock (&def_dl_bandwidth.dl_runtime_lock); dl_b->total_bw =0 ; }
@@ -612,6 +612,29 @@ static void update_curr_dl(struct rq *rqif (!is_leftmost (curr, &rq->dl))resched_task (curr); } + +/* +* Because -- for now -- we share the rt bandwidth, we need to +* account our runtime there too, otherwise actual rt tasks +* would be able to exceed the shared quota. +* +* Account to the root rt group for now. +* +* The solution we're working towards is having the RT groups scheduled +* using deadline servers -- however there's a few nasties to figure +* out before that can happen. +*/ +if (rt_bandwidth_enabled ()) { +struct rt_rq *rt_rq = &rq->rt; + +raw_spin_lock (&rt_rq->rt_runtime_lock); + rt_rq->rt_time += delta; +/* +* We'll let actual RT tasks worry about the overflow here, we +* have our own CBS to keep us inline -- see above. +*/ +raw_spin_unlock (&rt_rq->rt_runtime_lock); + } }#ifdef CONFIG_SMP
kernel/sched/sched.h +1 -17
@@ -176,7 +176,7 @@ struct dl_bandwidth {static inline int dl_bandwidth_enabled (void ) { -return sysctl_sched_dl_runtime >=0 ; +return sysctl_sched_rt_runtime >=0 ; }extern struct dl_bw *dl_bw_of (int i);
@@ -186,9 +186,6 @@ struct dl_bw {u64 bw, total_bw; }; -static inline u64 global_dl_period (void ); -static inline u64 global_dl_runtime (void ); -extern struct mutex sched_domains_mutex;#ifdef CONFIG_CGROUP_SCHED
@@ -953,19 +950,6 @@ static inline u64 global_rt_runtime(voidreturn (u64 )sysctl_sched_rt_runtime *NSEC_PER_USEC ; } -static inline u64 global_dl_period (void ) -{ -return (u64 )sysctl_sched_dl_period *NSEC_PER_USEC ; -} - -static inline u64 global_dl_runtime (void ) -{ -if (sysctl_sched_dl_runtime <0 ) -return RUNTIME_INF ; - -return (u64 )sysctl_sched_dl_runtime *NSEC_PER_USEC ; -} -static inline int task_current (struct rq *rq,struct task_struct *p) {return rq->curr == p;
kernel/sysctl.c +0 -14
@@ -414,20 +414,6 @@ static struct ctl_table kern_table[] = { .mode = 0644, .proc_handler = sched_rr_handler, }, - { - .procname = "sched_dl_period_us", - .data = &sysctl_sched_dl_period, - .maxlen = sizeof(unsigned int), - .mode = 0644, - .proc_handler = sched_dl_handler, - }, - { - .procname = "sched_dl_runtime_us", - .data = &sysctl_sched_dl_runtime, - .maxlen = sizeof(int), - .mode = 0644, - .proc_handler = sched_dl_handler, - },#ifdef CONFIG_SCHED_AUTOGROUP { .procname = "sched_autogroup_enabled",
Steven Rostedt
maintainerPATCH 1/1 sched, deadline: Properly initialize def_dl_bandwidth lock
In reply to Peter ZijlstraSpinlocks even in structures require to be properly initialized.
kernel/sched/deadline.c +3 -1
@@ -18,7 +18,9 @@#include <linux/slab.h> -struct dl_bandwidth def_dl_bandwidth; +struct dl_bandwidth def_dl_bandwidth = { + .dl_runtime_lock =__RAW_SPIN_LOCK_UNLOCKED (def_dl_bandwidth.dl_runtime_lock), +};static inline struct task_struct *dl_task_of (struct sched_dl_entity *dl_se) {
Peter Zijlstra
maintainerRe: [PATCH] sched, deadline: Properly initialize def_dl_bandwidth lock
Quoted 10 lines · Steven Rostedt
Spinlocks even in structures require to be properly initialized.
Signed-off-by Steven Rostedt <[email protected]>Index:
linux-rt.git/kernel/sched/deadline.c
===================================================================
kernel/sched/deadline.c line 26
Quoted 10 lines
kernel/sched/deadline.c +3
-1@@ -18,7 +18,9 @@#include <linux/slab.h> -struct dl_bandwidth def_dl_bandwidth; +struct dl_bandwidth def_dl_bandwidth = { + .dl_runtime_lock =__RAW_SPIN_LOCK_UNLOCKED (def_dl_bandwidth.dl_runtime_lock), +};static inline struct task_struct *dl_task_of (struct sched_dl_entity *dl_se) {
The thing is, init_dl_bandwidth() in sched_init() is supposed to already do that. The stacktrace you provided out of band:
[ 0.000000] [<ffffffff814e2aca>] spin_bug+0x2b/0x2d [ 0.000000] [<ffffffff8107535c>] do_raw_spin_lock+0x27/0x104 [ 0.000000] [<ffffffff814ec32e>] _raw_spin_lock+0x20/0x24 [ 0.000000] [<ffffffff8106fc41>] init_dl_bw+0x2d/0x79^M [ 0.000000] [<ffffffff810607b9>] init_rootdomain+0x20/0x4f^M [ 0.000000] [<ffffffff81b0db07>] sched_init+0x69/0x432 [ 0.000000] [<ffffffff81af3b6c>] start_kernel+0x201/0x41c [ 0.000000] [<ffffffff81af3773>] ? repair_env_string+0x56/0x56 [ 0.000000] [<ffffffff81af3487>] x86_64_start_reservations+0x2a/0x2c [ 0.000000] [<ffffffff81af357b>] x86_64_start_kernel+0xf2/0xf9
Has clue though. So it appears we use the lock before we reach that init_dl_bandwidth.
The below hunk should fix things up -- merged into patch 9/13.
kernel/sched/core.c +4 -4
@@ -6768,15 +6768,15 @@ void __init sched_init(void)#endif /* CONFIG_CPUMASK_OFFSTACK */ } -#ifdef CONFIG_SMP -init_defrootdomain (); -#endif -init_rt_bandwidth (&def_rt_bandwidth,global_rt_period (),global_rt_runtime ());init_dl_bandwidth (&def_dl_bandwidth,global_dl_period (),global_dl_runtime ()); +#ifdef CONFIG_SMP +init_defrootdomain (); +#endif +#ifdef CONFIG_RT_GROUP_SCHED init_rt_bandwidth (&root_task_group.rt_bandwidth,global_rt_period (),global_rt_runtime ());
Hi,
Quoted 10 lines · Peter Zijlstra
Hai..
This is my current queue of
SCHED_DEADLINE; which I hope to merge 'soon'.Juri handed me a version that should've (didn't check) included all feedback including the new
sched_attrinterface.I did clean up some of the patches; moved some hunks around so that each patch compiles on its own etc..
Quoted 9 lines
I then did a number of patches at the end to change some actual stuff around.
Juri do you have some userspace around to test with? I'm just too likely to have wrecked everything; so if you don't have something I need to go write something before merging this :-)
No need to update your test proglets to the new interface, I can lift it if that is more convenient -- I know you're conferencing atm.
I use this: https://github.com/gbagnoli/rt-app/tree/new-ABI
It is aligned with the new ABI (but it is missing your last changes).
Quoted 4 lines
One question; the SoB chain in patch 2/13 seems weird; I suppose that patch is a collaborative effort? could we cure that by mentioning Fabio and Michael in some other way?
We could change their SoB to be a Cc (not sure this cure the thing anyway). Not even Cc-ing them seems pointless. Then we have them mentioned in sched/deadline.c copyright (oh! s/2012/2014/ there :-O).
Thanks,
- Juri
Steven Rostedt
maintainerQuoted 8 lines · On Fri, 20 Dec 2013 14:51:18 +0100 Juri Lelli <[email protected]> wrote:
Quoted 4 lines
One question; the SoB chain in patch 2/13 seems weird; I suppose that patch is a collaborative effort? could we cure that by mentioning Fabio and Michael in some other way?
We could change their SoB to be a Cc (not sure this cure the thing anyway). Not even Cc-ing them seems pointless. Then we have them mentioned in
sched/deadline.ccopyright (oh! s/2012/2014/ there :-O).
Well, if they were involved in the development of the code, then their SoB's would be appropriate. That copyright seems to state that they are required.
-- Steve
Peter Zijlstra
maintainerQuoted 2 lines · Juri Lelli
I use this: https://github.com/gbagnoli/rt-app/tree/new-ABI
It is aligned with the new ABI (but it is missing your last changes).
I'm a moron, I can't find how to make github get me a git:// url I can clone from.
Steven Rostedt
maintainerQuoted 6 lines · On Fri, 20 Dec 2013 15:51:40 +0100 Peter Zijlstra <[email protected]> wrote:
Quoted 2 lines · Juri Lelli
I use this: https://github.com/gbagnoli/rt-app/tree/new-ABI
It is aligned with the new ABI (but it is missing your last changes).I'm a moron, I can't find how to make github get me a
git://url I can clone from.
I don't think you can use git:// but you can do:
git clone https://github.com/gbagnoli/rt-app.git
-- Steve