Provided by:
manpages-fr-dev_3.27fr1.4-1_all 
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> >>.