sched_setscheduler (2)


       sched_setscheduler,  sched_getscheduler  - set and get scheduling algo-


       #include <sched.h>

       int sched_setscheduler(pid_t pid, int policy, const struct  sched_param

       int sched_getscheduler(pid_t pid);

       struct sched_param {
           int sched_priority;


       sched_setscheduler  sets  both the scheduling policy and the associated
       parameters for the process identified by pid. If pid equals  zero,  the
       scheduler of the calling process will be set. The interpretation of the
       parameter p depends on the selected policy.  Currently,  the  following
       three  scheduling  policies  are  supported  under  Linux:  SCHED_FIFO,
       SCHED_RR, and SCHED_OTHER; their  respective  semantics  are  described

       sched_getscheduler  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.

   Scheduling Policies
       The  scheduler  is  the kernel part that decides which runnable process
       will be executed by the CPU next. The Linux scheduler offers three dif-
       ferent  scheduling policies, one for normal processes and two for real-
       time applications. A static priority value sched_priority  is  assigned
       to  each  process  and this value can be changed only via system calls.
       Conceptually, the scheduler maintains a list of runnable processes  for
       each possible sched_priority value, and sched_priority can have a value
       in the range 0 to 99. In order to determine the process that runs next,
       the  Linux  scheduler  looks  for  the  non-empty list with the highest
       static priority and takes the process at the head  of  this  list.  The
       scheduling  policy  determines  for  each  process,  where  it  will be
       inserted into the list of processes with equal static priority and  how
       it will move inside this list.

       SCHED_OTHER is the default universal time-sharing scheduler policy used
       by most processes, SCHED_FIFO and SCHED_RR  are  intended  for  special
       time-critical  applications  that  need precise control over the way in
       which runnable processes are selected for execution.  Processes  sched-
       uled with SCHED_OTHER must be assigned the static priority 0, processes
       scheduled under SCHED_FIFO or SCHED_RR can have a  static  priority  in
       the  range  1 to 99. Only processes with superuser privileges can get a
       ordering within the list of runnable processes with equal static prior-

   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
       preempt immediately any currently running normal  SCHED_OTHER  process.
       SCHED_FIFO  is  a simple scheduling algorithm without time slicing. For
       processes scheduled under the SCHED_FIFO policy,  the  following  rules
       are  applied:  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
       priority 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  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  pro-
       cess  if  it  has  the same priority.  (POSIX 1003.1 specifies that the
       process should  go  to  the  end  of  the  list.)   A  process  calling
       sched_yield  will  be  put at the end of the list. No other events will
       move a process scheduled under the SCHED_FIFO policy 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.

   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 pro-
       cess 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 by sched_rr_get_interval.

   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 special static priority real-time mecha-
       nisms. 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 level (set  by  the  nice  or
       setpriority  system  call) and increased for each time quantum the pro-
       cess is ready to run, but denied to run by the scheduler. This  ensures
       fair progress among all SCHED_OTHER processes.

   Response time
       A  blocked  high  priority  process  waiting  for the I/O has a certain
       response time before it is scheduled again. The  device  driver  writer
       can  greatly  reduce  this  response  time  by using a "slow interrupt"
       interrupt handler.
       As a non-blocking end-less loop in a process scheduled under SCHED_FIFO
       or  SCHED_RR  will  block  all processes with lower priority forever, a
       software developer should always keep available on the console a  shell
       scheduled  under  a higher static priority than the tested application.
       This will allow an emergency kill of tested real-time applications that
       do  not block or terminate as expected. As SCHED_FIFO and SCHED_RR pro-
       cesses can preempt other processes forever,  only  root  processes  are
       allowed to activate these policies under Linux.

       POSIX  systems  on  which sched_setscheduler and sched_getscheduler are
       available define _POSIX_PRIORITY_SCHEDULING in <unistd.h>.


       On   success,   sched_setscheduler   returns   zero.     On    success,
       sched_getscheduler  returns  the policy for the process (a non-negative
       integer).  On error, -1 is returned, errno is set appropriately.


       ESRCH  The process whose ID is pid could not be found.

       EPERM  The calling process does not have appropriate  privileges.  Only
              root  processes  are  allowed  to  activate  the  SCHED_FIFO and
              SCHED_RR policies. The process calling sched_setscheduler  needs
              an effective uid equal to the euid or uid of the process identi-
              fied by pid, or it must be a superuser process.

       EINVAL The scheduling policy is not one of the recognized policies,  or
              the parameter p does not make sense for the policy.


       POSIX.1b (formerly POSIX.4)


       As  of  linux-1.3.81,  SCHED_RR  has  not yet been tested carefully and
       might not behave exactly as described or required by POSIX.1b.


       Standard Linux is a general-purpose operating  system  and  can  handle
       background  processes,  interactive  applications,  and  soft real-time
       applications (applications that need to usually meet timing deadlines).
       This man page is directed at these kinds of applications.

       Standard  Linux is not designed to support hard real-time applications,
       that is, applications in which deadlines (often  much  shorter  than  a
       second)  must  be  guaranteed or the system will fail catastrophically.
       Like all general-purpose operating systems, Linux is designed to  maxi-
       mize  average  case  performance  instead  of  worst  case performance.
       Linux's worst case performance for interrupt handling  is  much  poorer
       than  its average case, its various kernel locks (such as for SMP) pro-
       duce long maximum wait times, and many of its  performance  improvement
       techniques  decrease  average  time by increasing worst-case time.  For
       most situations, that's what you want, but if you truly are  developing
       a  hard real-time application, consider using hard real-time extensions
       to Linux such as RTLinux ( or  use  a  different
       operating system designed specifically for hard real-time applications.

       ISO/IEC 9945-1:1996 - This is the new 1996 revision  of  POSIX.1  which
       contains   in   one   single  standard  POSIX.1(1990),  POSIX.1b(1993),
       POSIX.1c(1995), and POSIX.1i(1995).

Linux 2.4.18                      2002-06-25                   SETSCHEDULER(2)