Man Sched_setscheduler en français
SETSCHEDULER(2)           Manuel du programmeur Linux          SETSCHEDULER(2)



 

NOM


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

 

SYNOPSIS


       #include 

       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 identifie par pid.  Si pid vaut zero,
       la politique du processus en cours  sera  fixee.   L'interpretation  du
       parametre  param  depend de la politique employee. Actuellement, il y a
       trois  politiques   proposees   par   Linux :   SCHED_FIFO,   SCHED_RR,
       SCHED_OTHER   et   SCHED_BATCH.   Leurs  semantiques  respectives  sont
       decrites ci-dessous.

       sched_getscheduler() lit la politique  d'ordonnancement et ses  parame-
       tres  pour  le processus identifie par pid.  Si pid vaut zero, la poli-
       tique du processus en cours sera recuperee.

   Politiques d'ordonnancement
       L'ordonnanceur est la partie du noyau qui decide quel processus pret va
       etre  execute ensuite. L'ordonnanceur de Linux propose trois politiques
       differentes, une pour les processus classiques, et deux pour les appli-
       cations a vocation temps-reel.

       Une  valeur  de  priorite statique sched_priority est assignee a chaque
       processus, et ne peut etre modifiee que  par  l'intermediaire  d'appels
       systemes.  Conceptuellement, l'ordonnanceur dispose d'une liste de tous
       les processus prets  pour  chaque  valeur  possible  de  sched_priority
       (sched_priority est dans l'intervalle 0 a 99).

       Afin  de  determiner  quel  processus doit s'executer ensuite, l'ordon-
       nanceur de Linux recherche la liste non-vide  de  plus  haute  priorite
       statique  et  prend  le processus en tete de cette liste.  La politique
       d'ordonnancement determine pour chaque processus  l'emplacement  ou  il
       sera insere dans la liste contenant les processus de meme priorite sta-
       tique, et comment il se deplacera dans cette liste.

       SCHED_OTHER est l'ordonnancement universel  temps-partage  par  defaut,
       utilise  par la plupart des processus.  SCHED_BATCH est concue pour les
       executions de type  batch  des processus.  SCHED_FIFO et SCHED_RR  sont
       prevus  pour  des  applications  temps reel qui necessitent un controle
       precis de la selection des processus prets.

       Les processus ordonnances avec SCHED_OTHER ou SCHED_BATCH doivent avoir
       une priorite statique de 0, ceux ordonnances par SCHED_FIFO ou SCHED_RR
       peuvent avoir une priorite statique dans  l'intervalle  1  a  99.   Les
       appels systemes sched_get_priority_min et sched_get_priority_max perme-
       ttent de  determiner  l'intervalle  de  priorites  valides  de  maniere
       portable sur les systemes conformes a la norme POSIX.1-2001.

       Tout  ordonnancement  est preemptif : si un processus avec une priorite
       statique plus elevee devient pret, le processus en cours est interrompu
       et  retourne  dans  sa  liste  d'attente. 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 arrive, premier
       servi)
       SCHED_FIFO  ne  peut  etre  utilise  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 ou SCHED_BATCH  en  cours
       d'execution sera interrompu.  SCHED_FIFO est un ordonnancement simple a
       base  de  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  plac-
       era le processus SCHED_FIFO identifie par pid a la fin de sa liste s'il
       est pret.  Un processus appelant sched_yield sera place a la fin de  sa
       liste.  Aucun autre evenement ne modifiera l'ordre des listes de prior-
       ites statiques egales avec SCHED_FIFO.  Un processus SCHED_FIFO  s'exe-
       cute  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.

   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  pro-
       cessus  sous  SCHED_RR  qui a ete preempte par un processus de priorite
       superieure terminera sa tranche de temps lorsqu'il reprendra son execu-
       tion.    La   longueur   du   time   quantum   peut   etre   lue   avec
       sched_rr_get_interval(2).

   SCHED_OTHER: Ordonnancement temps-partage par defaut
       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 pri-
       orite dynamique est basee sur la valeur de  gentillesse   du  processus
       (fixee  avec  les  appels  systemes  nice(2)  ou setpriority(2)) et est
       incrementee a chaque time quantum ou le processus  est  pret  mais  non
       selectionne  par  l'ordonnanceur.   Ceci garantit une progression equi-
       table de tous les processus SCHED_OTHER.

   SCHED_BATCH: Ordonnancement par lot de processus
       (Depuis Linux 2.6.16.)  SCHED_BATCH ne peut etre  utilise  qu'avec  une
       priorite  statique  de 0.  Cette politique est similaire a SCHED_OTHER,
       excepte que cette politique fera que l'ordonnanceur supposera  toujours
       que  le  processus est exigeant en CPU.  Par consequent, l'ordonnanceur
       appliquera une petite penalite d'ordonnancement de sorte que ce proces-
       sus  est  doucement  defavorise  dans  les  decisions d'ordonnancement.
       Cette politique est utile pour les charges de travail qui ne  sont  pas
       interactives  mais  qui  ne  veulent  pas diminuer leur valeur de cour-
       toisie, et pour les  charges  de  travail  qui  veulent  une  politique
       d'ordonnancement deterministe sans interactivite provoquant des preemp-
       tions supplementaires (entre les tches des charges de travail).

   Privileges et limites de ressources
       Dans les noyaux Linux anterieur au 2.6.12, seuls les processus privile-
       gies  (CAP_SYS_NICE) peuvent fixer une priorite statique non nulle.  La
       seule modification que puisse faire un processus non privilegie est  de
       fiwer  la politique SCHED_OTHER, et cela ne peut etre fait que si l'UID
       effectif de l'appelant de sched_setscheduler() correspond a 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  sur  la  priorite d'un processus non privilegie pour les poli-
       tiques SCHED_RR et SCHED_FIFO.  Si un processus non  privilegie  a  une
       limite  logicielle  RLIMIT_RTPRIO non nulle, il peut modifier ses poli-
       tique et priorite d'ordonnancement, avec la restriction que la priorite
       ne  peut  pas etre configuree avec une valeur plus grande que la limite
       logicielle RLIMIT_RTPRIO.  Si la limite logicielle RLIMIT_RTPRIO est 0,
       la  seule modification permise est de diminuer la priorite.  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  pro-
       cessus   cible.    Voir   Pour  plus  d'informations  sur  getrlimit(2)
       RLIMIT_RTPRIO.  Les processus privilegies (CAP_SYS_NICE) ignorent cette
       limite ;  comme  avec de vieux noyaux, ils peuvent modifier, de maniere
       arbitraire, la politique et la priorite d'ordonnancement.

   Temps de reponse
       Un processus de haute priorite bloque en attente d'entrees-sorties  est
       affecte  d'un  certain temps de reponse avant d'etre selectionne a nou-
       veau. Le concepteur d'un  gestionnaire  de  peripherique  peut  reduire
       grandement ce temps de reponse en utilisant un gestionnaire d'interrup-
       tions lentes comme decrit dans request_irq(9).

   Divers
       Les processus fils heritent de la  politique  d'ordonnancement  et  des
       parametres  associes  lors d'un fork().  L'algorithme et les parametres
       d'ordonnancement sont preserves a travers 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'applica-
       tions  temps-reel  devrait  toujours conserver sur une console un shell
       ordonnance avec une priorite superieure a celle de  l'application  tes-
       tee.  Ceci permettra un kill((1) d'urgence des applications testees qui
       ne se bloquent pas ou qui ne se terminent pas comme prevu.

       Les systemes POSIX sur lesquels sched_setscheduler() et sched_getsched-
       uler()  sont  disponibles  definissent  _POSIX_PRIORITY_SCHEDULING dans
       .

 

VALEUR RENVOYEE


       sched_setscheduler() renvoie 0 s'il reussit  sched_getscheduler()  ren-
       voie la politique pour le processus 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
              le parametre param n'a pas de signification  pour  la  politique
              policy.

       EPERM  Le processus appelant n'a pas les privileges necessaires.

       ESRCH  Le processus numero pid n'existe pas.

 

CONFORMITE


       POSIX.1-2001.  La politique SCHED_BATCH est specifique a Linux.

 

NOTES


       Le noyau Linux standard est un systeme d'exploitation a vocation gener-
       aliste, et peut gerer des processus en arriere-plan,  des  applications
       interactives,  et des applications en temps-reel souple (qui ont besoin
       de repondre a des criteres temporels moyens).  Cette page de manuel est
       prevue pour ce type d'applications.

       Le  noyau  Linux  standard n'est pas prevu pour le support des applica-
       tions en temps-reel strict, dans  lesquelles  les  limites  temporelles
       (souvent  inferieures  a  la  seconde) sont sres d'etre respectees sous
       risque d'echec catastrophique.  Comme tous  les  systemes  a  vocations
       generales,  Linux  est  prevu pour optimiser les performances moyennes.
       Les performances critiques pour la gestion des interruptions sont  bien
       pires que les performances moyennes, les verrous divers du noyau (comme
       ceux pour les SMP) creent de longs temps d'attente, plusieurs ameliora-
       tions  des  performances moyennes se font au detriment des performances
       critiques.  Pour la plupart des situations, c'est ce que  l'on  attend.
       Mais  si vous desirez de veritables performances temps-reel, il faut se
       tourner vers des  extensions  comme  RTLinux  (http://www.rtlinux.org),
       RTAI  (http://www.rtai.org)  ou un systeme d'exploitation concu pour le
       temps-reel strict.

 

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),  setprior-
       ity(2), capabilities(7)

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

 

TRADUCTION


       Ce   document   est  une  traduction  realisee  par  Christophe  Blaess
        le  14 octobre 1996  et  revisee  le
       14 aot 2006.

       L'equipe  de  traduction a fait le maximum pour realiser une adaptation
       francaise de qualite. La version anglaise la plus a jour de ce document
       est       toujours       consultable       via       la      commande :
        LANG=C man 2 sched_setscheduler .  N'hesitez pas a signaler a l'auteur
       ou au traducteur, selon le cas, toute erreur dans cette page de manuel.



Linux 2.6.16                     23 mars 2006                  SETSCHEDULER(2)