sched_setscheduler,   sched_getscheduler  -  set  and  get
       scheduling algorithm/parameters


       #include <sched.h>

       int sched_setscheduler(pid_t pid, int policy, const struct
       sched_param *p);

       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 is
       described below.

       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 different scheduling poli­
       cies, 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 main­
       tains 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  sched­
       tions  that  need  precise  control  over the way in which
       runnable processes are selected for  execution.  Processes
       scheduled  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  static
       priority  higher  than  0  and  can therefore be scheduled
       under   SCHED_FIFO   or   SCHED_RR.   The   system   calls
       sched_get_priority_min  and  sched_get_priority_max can be
       used to to  find  out  the  valid  priority  range  for  a
       scheduling  policy  in a portable way on all POSIX.1b con­
       forming systems.

       All scheduling is preemptive: If a process with  a  higher
       static  priority  gets  ready  to run, the current process
       will be preempted and returned into  its  wait  list.  The
       scheduling  policy only determines the ordering within the
       list of runnable processes with equal static priority.

   SCHED_FIFO: First In-First out scheduling
       SCHED_FIFO can only be used with static priorities  higher
       than  0,  that  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 fol­
       lowing 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 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_set­
       param will put the SCHED_FIFO process identified by pid at
       the end of the list if it was runnable. 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 max­
       imum  time quantum. If a SCHED_RR process has been running
       for a time period equal to or longer than the  time  quan­
       tum,  it will be put at the end of the list for its prior­
       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 processes  that  do  not  require
       special  static priority 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 level (set
       by  the nice or setpriority system call) 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.

   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 described
       in request_irq(9).

       Child  processes  inherit  the  scheduling  algorithm  and
       parameters across a fork.

       Memory  locking  is usually needed for real-time processes
       to avoid paging delays, this can be  done  with  mlock  or

       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  applica­
       tions  that  do  not  block  or  terminate as expected. As
       SCHED_FIFO and SCHED_RR processes can preempt  other  pro­
       cesses  forever,  only root processes are allowed to acti­
       vate these policies under Linux.

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


       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 priv­
              ileges. 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 identified
              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 care­
       fully  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  maximize
       average  case  performance  instead  of worst case perfor­
       mance.  Linux's worst case performance for interrupt  han­
       dling  is  much  poorer than its average case, its various
       kernel locks (such as for SMP) produce 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 sys­
       tem designed specifically for hard real-time applications.


       sched_setparam(2),   sched_getparam(2),    sched_yield(2),
       sched_get_priority_max(2),      sched_get_priority_min(2),

       Programming  for  the  real  world  -  POSIX.4  by Bill O.
       Gallmeister,   O'Reilly   &   Associates,    Inc.,    ISBN
       IEEE Std 1003.1b-1993 (POSIX.1b standard)
       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