Linux Certif

Toute la documentation sur la certification Linux LPI

Rechercher une page de manuel

sched_getscheduler

NOM

sched_setscheduler, sched_getscheduler - Lire/fixer la politique d'ordonnancement et ses paramètres

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 à 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 en cours sera fixée. L'interprétation du paramètre param dépend de la politique employée. Actuellement, il y a quatre politiques proposées par Linux : SCHED_FIFO, SCHED_RR, SCHED_OTHER et SCHED_BATCH. 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 en cours sera renvoyée.

Politiques d'ordonnancement

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èmes. 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 une exécution de processus de type traitement par lots. SCHED_FIFO et SCHED_RR sont conçus pour des applications temps-réel, qui nécessitent un contrôle précis de la façon dont les processus sont sélectionnés pour exécution.

Les processus ordonnancés avec SCHED_OTHER ou SCHED_BATCH 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() et sched_get_priority_max() 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 en cours 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)

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 ou SCHED_BATCH en cours d'exécution sera interrompu. SCHED_FIFO est un ordonnancement simple sans 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() placera le processus SCHED_FIFO (ou SCHED_RR) identifié par pid entête de sa liste s'il est prêt. Il pourra donc stopper le processus en cours d'exécution si sa priorité est au moins aussi grande. (Selon POSIX.1-2001, le processus devrait aller à la fin de sa liste.) Un processus appelant sched_yield() 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

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

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 « politesse » du processus (fixée avec les appels systèmes 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 de processus de traitement par lots

(Depuis Linux 2.6.16) SCHED_BATCH ne peut être utilisé qu'avec des priorités statiques à 0. Cette politique est similaire à SCHED_OTHER, sauf que l'ordonnanceur considérera toujours que ce processus demande beaucoup de ressources processeur. Par conséquent, il lui appliquera une pénalité d'ordonnancement, et le processus sera légèrement désavantagé dans les décisions 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 déterministe, sans que l'interactivité ne cause de préemptions supplémentaires.

Privilèges et limites de ressources

Avec les noyaux Linux antérieurs à 2.6.12, seuls les processus privilégiés (CAP_SYS_NICE) pouvaient attribuer une priorité statique non nulle. Le seul changement qu'un processus non privilégié pouvait faire était d'affecter la politique SCHED_OTHER, et seulement si l'UID effectif de l'appelant de sched_setscheduler() était le même que l'UID réel ou effectif du processus cible, dont la politique est modifiée.

Depuis Linux 2.6.12, la limite de ressource RLIMIT_RTPRIO définit un plafond pour 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 souple RLIMIT_RTPRIO non nulle, il peut changer sa politique et sa priorité d'ordonnancement, à condition que la priorité reste inférieure à la limite souple RLIMIT_RTPRIO. Si la limite souple RLIMIT_RTPRIO est nulle, la seule modification possible est une diminution de la priorité. Un autre processus non privilégié peut également faire ces modifications, avec les mêmes règles, pourvu que l'UID effectif du processus faisant la modification soit identique à 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 ; de même que sous les noyaux plus anciens, ils peuvent modifier de façon arbitraire les politique et priorité d'ordonnancement.

Temps de réponse

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.

Divers

Les processus fils héritent de la politique d'ordonnancement et des paramètres associés lors d'un fork(). 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

sched_setscheduler() renvoie 0 s'il réussit. sched_getscheduler() renvoie la politique pour le processus (un entier >= 0) s'il réussit. En cas d'échec, -1 est renvoyé et errno contient le code d'erreur.

ERREURS

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 ne possède pas les privilèges nécessaires.

ESRCH

Le processus numéro pid n'existe pas.

CONFORMITÉ

POSIX.1-2001. La politique SCHED_BATCH est spécifique à Linux.

NOTES

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). Cette page de manuel est prévue pour ce type d'applications.

Le noyau Linux standard n'est pas prévu pour le support des applications en temps-réel strict, dans lesquelles les limites temporelles (souvent inférieures à la seconde) sont sûres d'être respectées sous risque d'échec catastrophique. Comme tous les systèmes à vocation générale, Linux est prévu 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) créent de longs temps d'attente, plusieurs améliorations des performances moyennes se font au détriment des performances critiques. Pour la plupart des situations, c'est ce que l'on attend. Mais si vous désirez de véritables performances temps-réel, il faut se tourner vers des extensions comme RTLinux (http://www.rtlinux.org), RTAI (http://www.rtai.org) ou un système d'exploitation conçu pour le temps-réel 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), setpriority(2), capabilities(7)

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

TRADUCTION

Cette page de manuel a été traduite et mise à jour par Christophe Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis par Alain Portal <aportal AT univ-montp2 DOT fr> jusqu'en 2006, et mise à disposition sur http://manpagesfr.free.fr/.

Les mises à jour et corrections de la version présente dans Debian sont directement gérées par Julien Cristau <jcristau@debian.org> et l'équipe francophone de traduction de Debian.

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

Vous pouvez toujours avoir accès à la version anglaise de ce document en utilisant la commande « man -L C <section> <page_de_man> ».