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

     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  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 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 schedul-
     ing policy in a portable way on all POSIX.1b conforming sys-

     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 runn-
     able 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 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
     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_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  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  prior-
     ity  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  spe-
     cial  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 dev-
     ice driver writer can greatly reduce this response  time  by
     using  a  "slow interrupt" interrupt handler as described in

     Child processes inherit the scheduling algorithm and parame-
     ters across a fork.

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

     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 processes can preempt other processes forever, only
     root processes are allowed to activate these policies  under

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

     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.


     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),  mun-
     lockall(2), mlock(2), munlock(2).

     Programming for the real world -  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).