sched_setscheduler   Début   Suivant   Sommaire   Préc.page.lue   Accueil
Section: Manuel du programmeur Linux (2)
Updated: 7 mars 2008
Sommaire  



NOM   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
sched_setscheduler, sched_getscheduler - Lire/fixer la politique d'ordonnancement et ses paramètres  



SYNOPSIS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
#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   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
sched_setscheduler() définit à la fois la politique d'ordonnancement et ses paramètres pour le processus identifié par pid. Si pid vaut zéro, la politique du processus appelant sera définie. L'interprétation du paramètre param dépend de la politique employée. Actuellement, les politiques proposées par Linux sont : SCHED_FIFO, SCHED_RR, SCHED_OTHER, SCHED_BATCH et SCHED_IDLE. Leurs sémantiques respectives sont décrites ci-dessous.

sched_getscheduler() lit la politique d'ordonnancement et ses paramètres pour le processus identifié par pid. Si pid vaut zéro, la politique du processus appelant sera récupérée.  




Politiques d'ordonnancement   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
L'ordonnanceur est la partie du noyau qui décide quel processus prêt va être exécuté ensuite. L'ordonnanceur de Linux propose trois politiques différentes, une pour les processus classiques, et deux pour les applications à vocation temps réel.

Une valeur de priorité statique sched_priority est assignée à chaque processus, et ne peut être modifiée que par l'intermédiaire d'appels système. Conceptuellement, l'ordonnanceur dispose d'une liste de tous les processus prêts pour chaque valeur possible de sched_priority (sched_priority est dans l'intervalle 0 à 99).

Afin de déterminer quel processus doit s'exécuter ensuite, l'ordonnanceur de Linux recherche la liste non-vide de plus haute priorité statique et prend le processus en tête de cette liste. La politique d'ordonnancement détermine pour chaque processus l'emplacement où il sera inséré dans la liste contenant les processus de même priorité statique, et comment il se déplacera dans cette liste.

SCHED_OTHER est l'ordonnancement universel temps-partagé par défaut, utilisé par la plupart des processus. SCHED_BATCH est conçue pour les exécutions de type « batch » des processus. SCHED_IDLE est conçue pour les exécutions de très basse priorité de tâches en arrière-plan. SCHED_FIFO et SCHED_RR sont prévus pour des applications temps réel qui nécessitent un contrôle précis de la sélection des processus prêts.

Les processus ordonnancés avec SCHED_OTHER, SCHED_BATCH ou SCHED_IDLE doivent avoir une priorité statique de 0, ceux ordonnancés par SCHED_FIFO ou SCHED_RR peuvent avoir une priorité statique dans l'intervalle 1 à 99. Les appels système sched_get_priority_min(2) et sched_get_priority_max(2) permettent de déterminer l'intervalle de priorités valides de manière portable sur les systèmes conformes à la norme POSIX.1-2001.

Tout ordonnancement est préemptif : si un processus avec une priorité statique plus élevée devient prêt, le processus appelant est interrompu et retourne dans sa liste d'attente. La politique d'ordonnancement détermine simplement l'ordre utilisé dans une liste de processus prêts avec des priorités statiques égales.  




SCHED_FIFO : Ordonnancement First In-First out (premier arrivé, premier servi)   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
SCHED_FIFO ne peut être utilisé qu'avec des priorités statiques supérieures à 0, ce qui signifie que dès qu'un processus SCHED_FIFO devient prêt, un processus normal SCHED_OTHER, SCHED_BATCH ou SCHED_IDLE en cours d'exécution sera interrompu. SCHED_FIFO est un ordonnancement simple à base de tranches de temps. Pour les processus ordonnancés par SCHED_FIFO les règles suivantes sont appliquées : un processus SCHED_FIFO qui a été préempté par un autre processus de priorité supérieure restera en tête de sa liste et reprendra son exécution dès que tous les processus de priorités supérieures sont à nouveau bloqués. Quand un processus SCHED_FIFO devient prêt, il est inséré à la fin de sa liste. Un appel système sched_setscheduler() ou sched_setparam(2) placera le processus SCHED_FIFO identifié par pid à la fin de sa liste s'il est prêt. Un processus appelant sched_yield(2) sera placé à la fin de sa liste. Aucun autre événement ne modifiera l'ordre des listes de priorités statiques égales avec SCHED_FIFO. Un processus SCHED_FIFO s'exécute jusqu'à ce qu'il soit bloqué par une opération d'entrée-sortie, qu'il soit préempté par un processus de priorité supérieure, ou qu'il appelle sched_yield().  



SCHED_RR: Ordonnancement Round Robin   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
SCHED_RR est une amélioration simple de la politique SCHED_FIFO. Tout ce qui est décrit pour SCHED_FIFO s'applique aussi à SCHED_RR, sauf que chaque processus ne dispose que d'une tranche temporelle limitée pour son exécution. Si un processus sous politique SCHED_RR s'est exécuté depuis une durée supérieure ou égale à la tranche temporelle (time quantum), il sera placé à la fin de la liste de sa priorité. Un processus sous SCHED_RR qui a été préempté par un processus de priorité supérieure terminera sa tranche de temps lorsqu'il reprendra son exécution. La longueur du time quantum peut être lue avec sched_rr_get_interval(2).  



SCHED_OTHER :: Ordonnancement temps-partagé par défaut   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
La politique SCHED_OTHER ne peut être utilisée qu'avec des priorités statiques à 0. C'est la politique standard de l'ordonnanceur temps partagé de Linux, et est conçue pour tous les processus ne réclamant pas de fonctionnalités temps-réel. Le processus à exécuter est choisi dans la liste des processus de priorités statiques nulles, en utilisant une priorité dynamique qui ne s'applique que dans cette liste. La priorité dynamique est basée sur la valeur de courtoisie du processus (définie avec les appels système nice(2) ou setpriority(2)) et est incrémentée à chaque time quantum où le processus est prêt mais non sélectionné par l'ordonnanceur. Ceci garantit une progression équitable de tous les processus SCHED_OTHER.  



SCHED_BATCH : Ordonnancement par lot de processus   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
(Depuis Linux 2.6.16.) SCHED_BATCH ne peut être utilisé qu'avec une priorité statique de 0. Cette politique est similaire à SCHED_OTHER en ce qu'elle ordonnance les processus conformément à leur priorité dynamique. La différence est que cette politique fera que l'ordonnanceur supposera toujours que le processus est exigeant en CPU. Par conséquent, l'ordonnanceur appliquera une petite pénalité d'ordonnancement, tout en respectant le comportement de réveil, de sorte que ce processus est doucement défavorisé dans les décisions 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 courtoisie, et pour les charges de travail qui veulent une politique d'ordonnancement déterministe sans interactivité provoquant des préemptions supplémentaires (entre les tâches des charges de travail).  



SCHED_IDLE: Scheduling very low priority jobs   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
 



SCHED_IDLE : Ordonnancement de tâches de très faible priorité   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
(Depuis Linux 2.6.23.) SCHED_IDLE ne peut être utilisée qu'avec une priorité statique de 0 ; la valeur de courtoisie n'a pas d'influence pour cette politique. Cette politique est conçue pour l'exécution de tâches de très faible priorité (inférieure même à une valeur de courtoisie +19 dans les politiques SCHED_OTHER ou SCHED_BATCH).  



Privilèges et limites de ressources   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Dans les noyaux Linux antérieur au 2.6.12, seuls les processus privilégiés (CAP_SYS_NICE) peuvent fixer une priorité statique non nulle. La seule modification que puisse faire un processus non privilégié est de fiwer la politique SCHED_OTHER, et cela ne peut être fait que si l'UID effectif de l'appelant de sched_setscheduler() correspond à l'UID réel ou effectif du processus cible (c'est-à-dire le processus spécifié par pid) dont la politique est modifiée.

Depuis Linux 2.6.12, la limite de ressources RLIMIT_RTPRIO définit un plafond sur la priorité d'un processus non privilégié pour les politiques SCHED_RR et SCHED_FIFO. Si un processus non privilégié a une limite logicielle RLIMIT_RTPRIO non nulle, il peut modifier ses politique et priorité d'ordonnancement, avec la restriction que la priorité ne peut pas être configurée 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 priorité. Soumis aux mêmes règles, un autre processus non privilégié peut également faire ces modifications à partir du moment où l'UID effectif du processus effectuant la modification correspond à l'UID réel ou effectif du processus cible. Voir getrlimit(2) Pour plus d'informations sur RLIMIT_RTPRIO. Les processus privilégiés (CAP_SYS_NICE) ignorent cette limite ; comme avec de vieux noyaux, ils peuvent modifier, de manière arbitraire, la politique et la priorité d'ordonnancement.  




Temps de réponse   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Un processus de haute priorité bloqué en attente d'entrées-sorties est affecté d'un certain temps de réponse avant d'être sélectionné à nouveau. Le concepteur d'un gestionnaire de périphérique peut réduire grandement ce temps de réponse en utilisant un gestionnaire d'interruptions lentes comme décrit dans request_irq(9).  



Divers   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Les processus fils héritent de la politique d'ordonnancement et des paramètres associés lors d'un fork(2). L'algorithme et les paramètres d'ordonnancement sont préservés à travers un execve(2).

Le verrouillage de pages en mémoire est généralement nécessaire pour les processus temps réel afin d'éviter les délais de pagination. Ceci peut être effectué avec mlock(2) ou mlockall(2).

Comme une boucle sans fin non bloquante dans un processus ordonnancé sous une politique SCHED_FIFO ou SCHED_RR bloquera indéfiniment tous les processus avec une priorité plus faible, le développeur d'applications temps-réel devrait toujours conserver sur une console un shell ordonnancé avec une priorité supérieure à celle de l'application testée. Ceci permettra un kill((1) d'urgence des applications testées qui ne se bloquent pas ou qui ne se terminent pas comme prévu.

Les systèmes POSIX sur lesquels sched_setscheduler() et sched_getscheduler() sont disponibles définissent _POSIX_PRIORITY_SCHEDULING dans <unistd.h>.  




VALEUR RENVOYÉE   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
sched_setscheduler() renvoie 0 s'il réussit sched_getscheduler() renvoie la politique pour le processus s'il réussit.

En cas d'échec, -1 est renvoyé et errno contient le code d'erreur.  




ERREURS   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
EINVAL
La valeur de politique d'ordonnancement policy n'existe pas, ou le paramètre param n'a pas de signification pour la politique policy.
EPERM
Le processus appelant n'a pas les privilèges nécessaires.
ESRCH
Le processus numéro pid n'existe pas.
 



CONFORMITÉ   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
POSIX.1-2001 (mais voir BOGUES plus loin). Les politiques SCHED_BATCH et SCHED_IDLE sont spécifiques à Linux.  



NOTES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
POSIX.1 ne détaille pas les permissions dont a besoin un processus non privilégié pour appeler sched_setscheduler(), et ces détails varient suivant les systèmes. Par exemple, la page de manuel de Solaris 7 dit que l'UID réel ou effectif du processus appelant doit correspondre à l'UID réel ou au SUID sauvé du processus cible.

À l'origine, le noyau Linux standard est un système d'exploitation à vocation généraliste, et peut gérer des processus en arrière-plan, des applications interactives, et des applications en temps réel souple (qui ont besoin de répondre à des critères temporels moyens). Bien que le noyau Linux 2.6 permettait la préemption du noyau et que le nouvellement introduit ordonnanceur 0(1) assure que le temps nécessaire pour planifier soit fixe et déterministe quel que soit le nombre de tâches, la vraie gestion temps réel n'était pas possible jusqu'au noyau 2.6.17.  




Fonctionalités temps réel dans le noyau Linux principal   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
Toutefois, depuis le noyau 2.6.18, Linux s'est vu graduellement équipé de possibilités temps réel, la plupart étant dérivées des ajouts de préemption temps réel réalisés par Ingo Molnar, Thomas Gleixner et autres. Jusqu'à ce que ces ajouts aient été entièrement fusionné dans le noyau principal (c'est attendu aux alentours des versions_ 2.6.24 ou 2.6.25), ils doivent être installés pour atteindre les meilleures performances temps réel. Ces ajouts s'appelent :
patch-version-noyau-rtversion-patch
et peuvent être téléchargés à partir de http://people.redhat.com/mingo/realtime-preempt/.

Sans les ajouts et avant leur complète inclusion dans le noyau principal, la configuration du noyau n'offre que trois classes de préemption CONFIG_PREEMPT_NONE, CONFIG_PREEMPT_VOLUNTARY et CONFIG_PREEMPT_DESKTOP qui fournissement respectivement « aucune », « quelque » et une « considérable » latence d'ordonnancement de pire cas.

Avec les ajouts appliqués ou après leur pleine inclusion dans le noyau principal, la configuration supplémentaire CONFIG_PREEMPT_RT supplémentaire devient disponible. Si elle est choisie, Linux est transformé en un système d'exploitation temps réel ordinaire. Les politiques d'ordonnancement FIFO et RR qui peuvent être définies avec sched_setscheduler() sont alors utilisées pour lancer un processus avec une vraie priorité temps réel et une latence minimum d'ordonnancement de pire cas.  




BOGUES   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
POSIX dit qu'en cas de réussite, sched_setscheduler() devrait retourner la politique d'ordonnancement précédente. should return the previous scheduling policy. La version Linux de sched_setscheduler() ne se conforme par à cette demande puisqu'il retourne toujours 0 en cas de réussite.  



VOIR AUSSI   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil
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)

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




TRADUCTION   Début   Précédent   Suivant   Sommaire   Préc.page.lue   Accueil

Ce document est une traduction réalisée par Christophe Blaess <http://www.blaess.fr/christophe/> le 14 octobre 1996 et révisée le 6 juin 2008.

L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 2 sched_setscheduler ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.


 



Sommaire   Début   Suivant   Sommaire   Préc.page.lue   Accueil
NOM
SYNOPSIS
DESCRIPTION
Politiques d'ordonnancement
SCHED_FIFO : Ordonnancement First In-First out (premier arrivé, premier servi)
SCHED_RR: Ordonnancement Round Robin
SCHED_OTHER :: Ordonnancement temps-partagé par défaut
SCHED_BATCH : Ordonnancement par lot de processus
SCHED_IDLE: Scheduling very low priority jobs
SCHED_IDLE : Ordonnancement de tâches de très faible priorité
Privilèges et limites de ressources
Temps de réponse
Divers
VALEUR RENVOYÉE
ERREURS
CONFORMITÉ
NOTES
Fonctionalités temps réel dans le noyau Linux principal
BOGUES
VOIR AUSSI
TRADUCTION

Table des mots clés   Début   Suivant   Sommaire   Préc.page.lue   Accueil
EINVALERREURS
EPERMERREURS
ESRCHERREURS



Ce document a été créé par man2html suivi de man2html.pl, le 17/10/2008 17:51:17, en utilisant les pages de 'man'.
 

Valid HTML 4.01 Transitional