SETSCHEDULER(2)     Linux Programmer's Manual     SETSCHEDULER(2)

NAME
       sched_setscheduler,   sched_getscheduler  -  set  and  get
       scheduling algorithm/parameters

SYNOPSIS
       #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;
           ...
       };

DESCRIPTION
       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-
       uler   policy  used  by  most  processes,  SCHED_FIFO  and
       SCHED_RR are intended for special  time-critical  applica-
       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-
       ity. 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 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).

   Miscellaneous
       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
       mlockall.

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

RETURN VALUE
       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.

ERRORS
       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 effec-
               tive  uid  equal to the euid or uid of the process
               identified by pid, or it must be a superuser  pro-
               cess.

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

CONFORMING TO
       POSIX.1b (formerly POSIX.4)

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

SEE ALSO
       sched_setparam(2),    sched_getparam(2),   sched_yield(2),
       sched_get_priority_max(2),      sched_get_priority_min(2),
       nice(2),   setpriority(2),   getpriority(2),  mlockall(2),
       munlockall(2), mlock(2), munlock(2).

       Programming for the  real  world  -  POSIX.4  by  Bill  O.
       Gallmeister,    O'Reilly    &   Associates,   Inc.,   ISBN
       1-56592-074-0
       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
       POSIX.1i(1995).

Linux 1.3.81                1996-04-10                          1