Provided by: manpages-fr-dev_3.27fr1.4-1_all bug

NOM

       sched_setscheduler,   sched_getscheduler   -  Lire/fixer  la  politique
       d'ordonnancement et ses parametres

SYNOPSIS

       #include <sched.h>

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

       int sched_getscheduler(pid_t pid);

       struct sched_param {
           ...
           int sched_priority;
           ...
       };

DESCRIPTION

       sched_setscheduler() fixe a la fois la  politique  d'ordonnancement  et
       ses  parametres  pour  le  processus dont l'identifiant est indique par
       pid. Si pid vaut zero, la politique d'ordonnancement et ses  parametres
       pour  le  processus  en cours sera fixee. L'interpretation du parametre
       param depend de la politique  employee.  Actuellement,  les  politiques
       normales  (c'est-a-dire  non  temps  reel) proposees par Linux sont les
       suivantes :

       SCHED_OTHER   politique standard de temps partage << round-robin >> :

       SCHED_BATCH   pour une  execution  de  style  traitement  par  lot  des
                     processus ; et

       SCHED_IDLE    pour  l'execution  de  taches  de tr`es faible priorite en
                     arriere-plan.

       Les politiques temps reel suivantes sont  egalement  gerees,  pour  des
       applications  particulieres  sensibles  au  temps  qui  necessitent  un
       controle precis sur la facon  dont  sont  choisis  pour  execution  les
       processus executables :

       SCHED_FIFO    une politique de << premier entre, premier sorti >> ; et

       SCHED_RR      une politique << round-robin >>.

       La semantique de chacune de ces politiques est decrite ci-dessous.

       sched_getscheduler()   lit   la   politique   d'ordonnancement  et  ses
       parametres pour le processus identifie par pid. Si pid  vaut  zero,  la
       politique du processus en cours sera renvoyee.

   Politiques d'ordonnancement
       L'ordonnanceur est la partie du noyau qui decide quel processus pret va
       etre execute ensuite. Chaque processus a une politique d'ordonnancement
       associee et une priorite d'ordonnancement statique, sched_priority ; ce
       sont les reglages  modifies  par  sched_setscheduler().  L'ordonnanceur
       prend  ses decisions en fonction de la politique d'ordonnancement et de
       la priorite statique de tous les processus du systeme.

       Pour   les   processus   ordonnances   sous   l'une   des    politiques
       d'ordonnancement   normales   (SCHED_OTHER,  SCHED_IDLE,  SCHED_BATCH),
       sched_priority n'est pas utilisee dans les  decisions  d'ordonnancement
       (et doit valoir 0).

       Les  processus  ordonnances  sous l'une des politiques d'ordonnancement
       temps reel (SCHED_FIFO, SCHED_RR) ont une valeur de sched_priority dans
       l'intervalle  1 (faible) a 99 (haute). (Comme les nombres l'impliquent,
       les processus temps reel ont toujours une priorite plus haute  que  les
       processus   normaux.)   Notez  bien :  POSIX.1-2001  ne  reclame  d'une
       implementation qu'elle gere  un  minimum  de  32  niveaux  de  priorite
       distincts pour les politiques temps reel et certains systemes n'offrent
       que   ce   minimum.   Les   programmes   portables   doivent   utiliser
       sched_get_priority_min(2)  et  sched_get_priority_max(2) pour connaitre
       l'intervalle des priorites gerees pour une politique particuliere.

       Conceptuellement,  l'ordonnanceur  dispose  d'une  liste  de  tous  les
       processus  prets pour chaque valeur possible de sched_priority. Afin de
       determiner  quel  processus  doit  s'executer  ensuite,  l'ordonnanceur
       recherche  la liste non vide de plus haute priorite statique et choisit
       le processus en tete de cette liste.

       La politique d'ordonnancement d'un processus determine l'emplacement ou
       il  sera  insere dans la liste contenant les processus de meme priorite
       statique, et comment il se deplacera dans cette liste.

       Tout ordonnancement est preemptif : si un processus avec  une  priorite
       statique  plus  elevee devient pret, le processus actuellement en cours
       d'execution est interrompu et retourne dans la liste d'attente avec son
       niveau  de  priorite  statique. La politique d'ordonnancement determine
       simplement l'ordre utilise dans une liste de processus prets  avec  des
       priorites statiques egales.

   SCHED_FIFO :  Ordonnancement  First  In-First  Out (premier arriv'e, premier
       servi)
       SCHED_FIFO ne  peut  etre  utilisee  qu'avec  des  priorites  statiques
       superieures  a  0,  ce  qui signifie que des qu'un processus SCHED_FIFO
       devient  pret,  un  processus  normal   SCHED_OTHER,   SCHED_BATCH   ou
       SCHED_IDLE  en  cours  d'execution  sera  interrompu. SCHED_FIFO est un
       ordonnancement simple  sans  tranches  de  temps.  Pour  les  processus
       ordonnances par SCHED_FIFO les regles suivantes sont appliquees :

       *  Un processus SCHED_FIFO qui a ete preempte par un autre processus de
          priorite superieure restera en tete de sa  liste  et  reprendra  son
          execution des que tous les processus de priorites superieures sont a
          nouveau bloques.

       *  Quand un processus SCHED_FIFO devient pret, il est insere a  la  fin
          de sa liste.

       *  Un  appel  systeme sched_setscheduler() ou sched_setparam(2) placera
          le processus SCHED_FIFO (ou SCHED_RR) identifie par pid en  tete  de
          sa liste s'il est pret. Il pourra donc stopper le processus en cours
          d'execution si  sa  priorite  est  au  moins  aussi  grande.  (Selon
          POSIX.1-2001, le processus devrait aller a la fin de sa liste.)

       *  Un  processus  appelant  sched_yield(2)  sera  place  a la fin de sa
          liste.

       Aucun autre evenement ne modifiera  l'ordre  des  listes  de  priorites
       statiques egales avec SCHED_FIFO.

       Un  processus SCHED_FIFO s'execute jusqu'a ce qu'il soit bloque par une
       operation d'entree-sortie, qu'il soit  preempte  par  un  processus  de
       priorite superieure, ou qu'il appelle sched_yield(2).

   SCHED_RR : Ordonnancement Round Robin
       SCHED_RR  est  une amelioration simple de la politique SCHED_FIFO. Tout
       ce qui est decrit pour SCHED_FIFO s'applique aussi a SCHED_RR, sauf que
       chaque  processus  ne dispose que d'une tranche temporelle limitee pour
       son execution. Si un processus sous politique  SCHED_RR  s'est  execute
       depuis  une  duree  superieure  ou  egale a la tranche temporelle (time
       quantum), il sera place a la  fin  de  la  liste  de  sa  priorite.  Un
       processus sous SCHED_RR qui a ete preempte par un processus de priorite
       superieure terminera  sa  tranche  de  temps  lorsqu'il  reprendra  son
       execution.  La  longueur  du  quantum  de  temps  peut  etre  lue  avec
       sched_rr_get_interval(2).

   SCHED_OTHER : Ordonnancement temps-partag'e par d'efaut
       La politique SCHED_OTHER ne peut etre utilisee  qu'avec  des  priorites
       statiques  a  0.  C'est  la  politique standard de l'ordonnanceur temps
       partage de Linux, et est concue pour tous les  processus  ne  reclamant
       pas  de  fonctionnalites temps-reel. Le processus a executer est choisi
       dans la liste des processus de priorites statiques nulles, en utilisant
       une  priorite  dynamique  qui  ne  s'applique  que dans cette liste. La
       priorite dynamique est  basee  sur  la  valeur  de  << politesse >>  du
       processus  (fixee avec les appels systeme nice(2) ou setpriority(2)) et
       est incrementee a chaque quantum de temps ou le processus est pret mais
       non  selectionne  par  l'ordonnanceur.  Ceci  garantit  une progression
       equitable de tous les processus SCHED_OTHER.

   SCHED_BATCH : Ordonnancement de processus de traitement par lots
       (Depuis Linux 2.6.16) SCHED_BATCH ne peut  etre  utilisee  qu'avec  une
       priorite statique de 0. Cette politique est similaire a SCHED_OTHER, en
       ce qu'elle  ordonnance  les  processus  conformement  a  leur  priorite
       dynamique  (basee  sur  la  valeur de politesse). La difference est que
       cette politique fera que l'ordonnanceur  considerera  toujours  que  ce
       processus demande beaucoup de ressources processeur. Par consequent, il
       lui appliquera une penalite d'ordonnancement vis-a-vis du  comportement
       au  reveil,  et  le  processus  sera  legerement  desavantage  dans les
       decisions d'ordonnancement.

       Cette politique est utile pour les processus non interactifs, mais  qui
       ne  souhaitent  pas diminuer leur valeur de politesse, ou pour ceux qui
       veulent  une  politique   d'ordonnancement   deterministe,   sans   que
       l'interactivite ne cause de preemptions supplementaires.

   SCHED_IDLE : Ordonnancement de t^aches de tr`es faible priorit'e
       (Depuis  Linux  2.6.23.)  SCHED_IDLE  ne peut etre utilisee qu'avec une
       priorite statique de 0 ; la valeur de courtoisie  n'a  pas  d'influence
       pour cette politique.

       Cette  politique  est  concue pour l'execution de taches de tres faible
       priorite (inferieure meme a une  valeur  de  courtoisie  +19  dans  les
       politiques SCHED_OTHER ou SCHED_BATCH).

   R'einitialiser la politique d'ordonnancement pour les processus fils
       Depuis  Linux 2.6.32, l'attribut SCHED_RESET_ON_FORK peut etre inclus a
       l'aide d'un OU binaire dans policy dans l'appel a sched_setscheduler().
       Avec  cet  attribut,  les  fils  crees  par  fork(2)  n'heritent pas de
       politiques  d'ordonnancement  privilegiees.  Cette  fonctionnalite  est
       prevue  pour  des  applications  de lecture audiovisuelle, et peut etre
       utilisee pour empecher les applications de passer outre  la  limite  de
       ressource  RLIMIT_RTTIME (consultez getrlimit(2)) en creant de nombreux
       processus fils.

       Plus precisement, si l'attribut SCHED_RESET_ON_FORK  est  utilise,  les
       regles  suivantes  seront appliquees lors de la creation ulterieure des
       fils :

       *  Si le processus appelant a une politique d'ordonnancement SCHED_FIFO
          ou  SCHED_RR, la politique pour les processus fils est reinitialisee
          a SCHED_OTHER.

       *  Si le processus appelant a une valeur de  politesse  negative,  elle
          est mise a zero pour les processus fils.

       Une fois que l'attribut SCHED_RESET_ON_FORK est active, il ne peut etre
       desactive que si le processus possede  la  capacite  CAP_SYS_NICE.  Cet
       attribut est desactive pour les processus fils crees avec fork(2).

       L'attribut  SCHED_RESET_ON_FORK  est  visible  dans  la  valeur  de  la
       politique du processus renvoyee par sched_getscheduler()

   Privil`eges et limites de ressources
       Avec  les  noyaux  Linux  anterieurs  a  2.6.12,  seuls  les  processus
       privilegies  (CAP_SYS_NICE)  pouvaient  attribuer une priorite statique
       non nulle (c'est-a-dire definir une  politique  d'ordonnancement  temps
       reel).  Le seul changement qu'un processus non privilegie pouvait faire
       etait d'affecter  la  politique  SCHED_OTHER,  et  seulement  si  l'UID
       effectif  de l'appelant de sched_setscheduler() etait le meme que l'UID
       reel ou effectif du processus cible (c'est-a-dire le processus specifie
       par pid), dont la politique est modifiee.

       Depuis  Linux 2.6.12,  la limite de ressources RLIMIT_RTPRIO definit un
       plafond pour la priorite statique d'un processus  non  privilegie  pour
       les  politiques  SCHED_RR  et  SCHED_FIFO.  Les regles pour modifier la
       politique d'ordonnancement et la priorite sont les suivantes :

       *  Si un processus non privilegie a une limite souple RLIMIT_RTPRIO non
          nulle,    il   peut   modifier   sa   politique   et   sa   priorite
          d'ordonnancement, a condition que la priorite  reste  inferieure  au
          maximum de sa priorite actuelle et a la limite souple RLIMIT_RTPRIO.

       *  Si   la   limite   souple   RLIMIT_RTPRIO   est  nulle,  les  seules
          modifications permises sont une diminution de la priorite ou bien un
          basculement vers une politique qui ne soit pas temps reel.

       *  Soumis  aux  memes  regles,  un  autre processus non privilegie peut
          egalement faire ces  modifications  a  partir  du  moment  ou  l'UID
          effectif  du processus effectuant la modification correspond a l'UID
          reel ou effectif du processus cible.

       *  Des regles particulieres s'appliquent a  SCHED_IDLE :  un  processus
          non  privilegie operant sous cette politique ne peut pas modifier sa
          politique, quelle  que  soit  la  valeur  de  sa  limite  souple  de
          ressources RLIMIT_RTPRIO.

       Les   processus   privilegies   (CAP_SYS_NICE)   ignorent   la   limite
       RLIMIT_RTPRIO : comme  avec  d'anciens  noyaux,  ils  peuvent  modifier
       arbitrairement  la politique d'ordonnancement et la priorite. Consultez
       getrlimit(2) pour plus d'informations sur RLIMIT_RTPRIO.

   Temps de r'eponse
       Un processus de haute priorite bloque en attente d'entrees-sorties  est
       affecte  d'un  certain  temps  de  reponse  avant  d'etre selectionne a
       nouveau. Le concepteur d'un gestionnaire de peripherique  peut  reduire
       grandement   ce   temps   de   reponse  en  utilisant  un  gestionnaire
       d'interruptions lentes.

   Divers
       Les processus fils heritent de la  politique  d'ordonnancement  et  des
       parametres  associes  lors d'un fork(2). L'algorithme et les parametres
       d'ordonnancement sont conserves au travers d'un execve(2).

       Le verrouillage de pages en memoire est  generalement  necessaire  pour
       les  processus temps reel afin d'eviter les delais de pagination ; ceci
       peut etre effectue avec mlock(2) ou mlockall(2).

       Comme une boucle sans fin non bloquante dans  un  processus  ordonnance
       sous  une  politique  SCHED_FIFO ou SCHED_RR bloquera indefiniment tous
       les  processus  avec  une  priorite   plus   faible,   le   developpeur
       d'applications temps-reel devrait toujours conserver sur une console un
       shell ordonnance avec une priorite superieure a celle de  l'application
       testee.  Ceci  permettra  un kill(1) d'urgence des applications testees
       qui ne se bloquent  pas  ou  qui  ne  se  terminent  pas  comme  prevu.
       Consultez   egalement   la  description  de  la  limite  de  ressources
       RLIMIT_RTTIME dans getrlimit(2).

       Les   systemes   POSIX    sur    lesquels    sched_setscheduler()    et
       sched_getscheduler()         sont        disponibles        definissent
       _POSIX_PRIORITY_SCHEDULING dans <unistd.h>.

VALEUR RENVOY'EE

       sched_setscheduler()  renvoie  0  s'il  reussit.   sched_getscheduler()
       renvoie  la  politique pour le processus (un entier >= 0) s'il reussit.
       En cas d'echec, -1 est renvoye et errno contient le code d'erreur.

ERREURS

       EINVAL La valeur de politique d'ordonnancement policy n'existe pas,  ou
              param n'a pas de signification pour la politique policy.

       EPERM  Le processus appelant ne possede pas les privileges necessaires.

       ESRCH  Le processus numero pid n'existe pas.

CONFORMIT'E

       POSIX.1-2001  (voir  la  section  BOGUES  ci-dessous).  Les  politiques
       SCHED_BATCH et SCHED_IDLE sont specifiques a Linux.

NOTES

       POSIX.1 ne detaille pas quelles permissions sont necessaire pour  qu'un
       processus  non  privilegie  puisse appeler sched_setscheduler(), et les
       details dependent des systemes. Par  exemple,  la  page  de  manuel  de
       Solaris  7  dit  que  l'UID reel ou effectif du processus appelant doit
       correspondre a l'UID reel ou sauve du processus vise.

       A l'origine, le noyau Linux standard visait un systeme d'exploitation a
       vocation  generaliste,  devant gerer des processus en arriere-plan, des
       applications interactives, et des applications  en  temps  reel  souple
       (qui  ont  besoin  en  general  de  repondre  a  des  criteres de temps
       maximal). Bien que le noyau Linux 2.6 ait permis la preemption du noyau
       et  que le nouvellement introduit ordonnanceur O(1) assure que le temps
       necessaire pour planifier soit fixe et deterministe quel  que  soit  le
       nombre  de  taches,  une  vraie gestion temps reel n'etait pas possible
       avant le noyau 2.6.17.

   Fonctionalit'es temps r'eel dans le noyau Linux principal
       Toutefois, depuis le noyau 2.6.18, Linux s'est vu graduellement  equipe
       de  possibilites  temps  reel,  la plupart etant derivees des ajouts de
       preemption temps reel  (realtime-preempt)  realises  par  Ingo  Molnar,
       Thomas  Gleixner,  Steven  Rostedt et autres. Jusqu'a ce que ces ajouts
       aient ete entierement fusionnes dans le noyau principal (c'est  attendu
       aux  alentours  des  versions  2.6.30), ils doivent etre installes pour
       atteindre  les  meilleures  performances   temps   reel.   Ces   ajouts
       s'appellent :

           patch-version-noyau-rtversion-patch

       et       peuvent       etre      telecharges      a      partir      de
       http://www.kernel.org/pub/linux/kernel/projects/rt/.

       Sans les  ajouts  et  avant  leur  complete  inclusion  dans  le  noyau
       principal,  la  configuration  du  noyau  n'offre  que trois classes de
       preemption     CONFIG_PREEMPT_NONE,     CONFIG_PREEMPT_VOLUNTARY     et
       CONFIG_PREEMPT_DESKTOP  qui  fournissement respectivement << aucune >>,
       << quelque >>  et  une  << considerable >>  reduction  de  la   latence
       d'ordonnancement de pire cas.

       Avec  les ajouts appliques ou apres leur pleine inclusion dans le noyau
       principal, la configuration  supplementaire  CONFIG_PREEMPT_RT  devient
       disponible.  Si  elle  est  choisie, Linux est transforme en un systeme
       d'exploitation temps reel ordinaire.  Les  politiques  d'ordonnancement
       FIFO  et  RR  qui  peuvent etre definies avec sched_setscheduler() sont
       alors utilisees pour lancer un processus avec une vraie priorite  temps
       reel et une latence minimum d'ordonnancement de pire cas.

BOGUES

       POSIX  dit qu'en cas de reussite, sched_setscheduler() devrait renvoyer
       la  politique  d'ordonnancement  precedente.  La   version   Linux   de
       sched_setscheduler()  ne  se  conforme  par a cette demande puisqu'elle
       renvoie toujours 0 en cas de reussite.

VOIR AUSSI

       getpriority(2),  mlock(2),  mlockall(2),   munlock(2),   munlockall(2),
       nice(2),      sched_get_priority_max(2),     sched_get_priority_min(2),
       sched_getaffinity(2),   sched_getparam(2),    sched_rr_get_interval(2),
       sched_setaffinity(2),         sched_setparam(2),        sched_yield(2),
       setpriority(2), capabilities(7), cpuset(7)

       Programming for the real  world  -  POSIX.4  de  Bill  O.  Gallmeister,
       O'Reilly & Associates, Inc., ISBN 1-56592-074-0

       Le  fichier Documentation/scheduler/sched-rt-group.txt dans les sources
       du noyau (depuis le noyau 2.6.25).

COLOPHON

       Cette page fait partie de  la  publication  3.27  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      etre       trouvees       a       l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis  2010,  cette  traduction est maintenue a l'aide de l'outil po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone        au        sein        du       projet       perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Christophe Blaess  <URL:http://www.blaess.fr/christophe/>  (1996-2003),
       Alain   Portal  <URL:http://manpagesfr.free.fr/>  (2003-2006).   Julien
       Cristau et l'equipe francophone de traduction de Debian (2006-2009).

       Veuillez  signaler  toute  erreur   de   traduction   en   ecrivant   a
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous pouvez toujours avoir acces a la version anglaise de  ce  document
       en utilisant la commande << man -L C <section> <page_de_man> >>.