*nix Documentation Project
·  Home
 +   man pages
·  Linux HOWTOs
·  FreeBSD Tips
·  *niX Forums

  man pages->Linux man pages -> sched_setscheduler (2)              



NAME    [Toc]    [Back]

       sched_setscheduler,  sched_getscheduler	- set and get scheduling algorithm/parameters

SYNOPSIS    [Toc]    [Back]

       #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;

DESCRIPTION    [Toc]    [Back]

       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    [Toc]    [Back]
       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 realtime
 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  scheduling policy in a portable way on all POSIX.1b conforming

       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  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_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
       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 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    [Toc]    [Back]
       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    [Toc]    [Back]
       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 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 Linux.

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

RETURN VALUE    [Toc]    [Back]

       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    [Toc]    [Back]

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

CONFORMING TO    [Toc]    [Back]

       POSIX.1b (formerly POSIX.4)

BUGS    [Toc]    [Back]

       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.

NOTE    [Toc]    [Back]

       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  performance.
       Linux's	worst  case  performance for interrupt handling 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 (http://www.rtlinux.org) or use a different
       operating system designed specifically for hard real-time applications.

SEE ALSO    [Toc]    [Back]

       sched_setparam(2),  sched_getparam(2), sched_yield(2), sched_get_prior-
       ity_max(2), sched_get_priority_min(2), nice(2), setpriority(2), getpri-
       ority(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 2.2.11			  1999-08-18		       SETSCHEDULER(2)
[ Back ]
 Similar pages
Name OS Title
pthread_getschedparam Tru64 Obtains the current scheduling policy and scheduling parameters of a thread
sched_setscheduler Tru64 Sets the scheduling policy and scheduling parameters of the specified process (P1003.1b)
pthread_setschedparam Tru64 Changes a thread's scheduling policy and scheduling parameters
CSP_GenerateAlgorithmParams Tru64 Generate algorithm parameters (CDSA)
CSSM_GenerateAlgorithmParams Tru64 Generate algorithm parameters (CDSA)
GenerateAlgorithmParams Tru64 Generate algorithm parameters (CDSA)
sched_setparam Linux set and get scheduling parameters
sched_getparam FreeBSD set/get scheduling parameters
sched_setparam FreeBSD set/get scheduling parameters
sched_getparam IRIX get the scheduling parameters of a process
Copyright © 2004-2005 DeniX Solutions SRL
newsletter delivery service