Ordonnanceur (scheduler) [2]

Ordonnanceur (scheduler) [1]
Systèmes d’exploitation
L’ordonnancement des processus
Lorsque +sieurs processus sont prêts, le SE doit choisir le processus à
exécuter
C’est l’ordonnanceur (scheduler) qui s’acquitte de cette tâche
L’algorithme utilisé est l’algorithme d’ordonnancement
L’ordonnanceur ne fournit pas un mécanisme, mais prend des
décisions concernant l’équité, l’efficacité, le temps de réponse, le
temps d’exécution et le rendement
Un bon algo doit :
–
–
–
–
–
S’assurer que chaque processus reçoit sa part de temps CPU
Utiliser le CPU à 100%
Minimiser le temps de réponse pour les utilisateurs en mode interactif
Minimiser l’attente des utilisateurs qui travaillent en traitement par lots
Maximiser le nombre de travaux effectués en une heure
Certains de ces objectifs sont contradictoires
Ordonnanceur (scheduler) [2]
Les ordonnanceurs doivent prévoir que chaque processus est unique et imprévisible
(impossible d’estimer le tps de calcul avant un blocage)
Pour assurer qu’aucun processus ne s’exécute pendant trop de temps, pratiquement
tous les ordinateurs ont un compteur de temps (timer) ou une horloge qui génère
périodiquement une interruption (un signal)
A chaque interruption le système reprend la main et décide si le processus courant
doit poursuivre son exécution ou s’il a épuisé le temps CPU qui lui était imparti, le
processeur est alors alloué à un autre processus
Cette stratégie qui permet de suspendre des processus prêts est appelée
ordonnancement avec réquisition (preemptive scheduling) et s’oppose à la méthode
d’exécution jusqu’à achèvement (ordonnancement sans réquisition) des premiers
systèmes à traitements par lots
Les algorithmes d’ordonnancement sans réquisition sont simples et faciles à mettre
en œuvre mais inadaptés à des systèmes généraux à plusieurs utilisateurs
L’ordonnancement circulaire
(tourniquet) [2]
Le seul problème est la durée du quantum !
La commutation de processus (ou commutation de contexte) requiert un
certain tps de gestion (sauvegarde et restitution des registres, …)
Durée de commutation : 5 ms et quantum : 20 ms Ä 20% du temps
CPU gâché pour la gestion : overhead
Solution : augmenter le quantum à 500 ms (Ä 1% pour gérer)
PB : 10 utilisateurs interactifs lancent leur programme presque en même
temps : le premier est lancé immédiatement, le second devra attendre ½
seconde et ainsi de suite. Le dernier attendra pendant 5 secondes !
Conclusion : un quantum trop petit provoque trop de commutations de
processus et abaisse l’efficacité du processeur, alors qu’un quantum
trop élevé augmente les temps de réponse de courtes commandes en
mode interactif
Un quantum de 100 ms est un compromis raisonnable
L’ordonnancement circulaire
(tourniquet) [1]
Un des algos les plus anciens, les plus simples, les plus fiables et les
plus utilisés est le tourniquet (round robin)
Chaque processus possède un intervalle de tps, son quantum, durant
lequel il est autorisé à s’exécuter
Si un processus s’exécute toujours au bout de son quantum, le CPU
est réquisitionné et alloué à un autre processus
Si le processus se bloque ou se termine avant la fin de son quantum,
le CPU est immédiatement alloué à un autre processus
L’ordonnanceur doit mémoriser une liste de processus prêts , lorsque
que le quantum est épuisé le processus est mis en fin de liste
Processus en cours
Processus suivant
B F D G A
Processus en cours
Processus suivant
Quantum de B épuisé
F D G A B
L’ordonnancement avec priorité [1]
Le modèle du tourniquet suppose que tous les processus
sont d’égale importance
Il reste qu’il est souvent utile que des processus soient plus
prioritaires que d’autres
Ceci conduit à un ordonnancement avec priorité
Idée : chaque processus à une priorité et on lance le
processus prêt dont la priorité est la plus élevée
Pour éviter que les processus de priorité élevée s’exécutent
indéfiniment, l’ordonnanceur diminue la priorité du processus
élu à chaque interruption d’horloge
Si cette priorité devient inférieure à celle du 2ème processus
de plus haute priorité, la commutation a lieu
1
L’ordonnancement avec priorité [2]
La commande nice d’UNIX permet à un utilisateur de réduire la priorité
de son processus pour être gentil envers les autres utilisateurs
(personne ne s’en sert !)
Les priorités peuvent être statiques ou dynamiques
Ex : les processus qui font beaucoup d’E/S, attendent la majeure partie
du tps la fin d’une E/S ; il faut donc leur allouer le CPU dès qu’ils le
demandent
Un bon algo consiste à donner à ces processus la priorité 1/f où f est la
fraction du quantum consommée
Un processus qui n’a utilisé que 2 ms de son quantum de 100 ms aura
une priorité de 50, alors qu’un autre qui se sera exécuté durant 50 ms
avant de se bloquer aura une priorité de 2 ; un processus qui aura
consommé tout son quantum aura une priorité de 1
Les files multiples
Comment répartir les processus dans les classes de priorités
Idée : A chaque dépassement de quantum
doubler son quantum et diminuer sa priorité
Ex : Un processus dure 100 quanta : il occupe 7 fois le CPU
(1,2,4,8,16,32,64) [37 quanta pour le dernier]
le processus descendant de priorité, il s’exécute de moins en
moins fréquemment et ménage donc le CPU pour les
processus courts en mode interactif
D’autres algos ont été proposés (ex : XDS 940 répartition
suivant 4 classes : terminal, E/S, quantum court, quantum
long)
L’ordonnancement
du plus court d’abord [2]
n travaux (t1, t2, …, tn), tps moyen = (n*t1+(n-1)*t2+ … + tn)/n
Le temps du premier travail intervenant davantage, il doit
donc être le plus court
L’algorithme du plus court d’abord minimise le tps
moyen d’exécution
Comment l’appliquer aux processus interactifs
Idée : souvent un proc = exec, attente, exec, attente, ….
Considérer chaque exec comme un proc particulier
Il reste à déterminer le + court des processus restant
Difficile, voire impossible, il faudra se contenter d’une
estimation
L’ordonnancement avec priorité [3]
Il est souvent pratique de regrouper en classe les processus en
fonction de leur priorité et d’utiliser l’ordonnancement avec priorité
entre les différentes classes et le tourniquet au sein de chaque classe
Tête des
Processus exécutables
files d’attente
Priorité 3
(Priorité la plus élevée)
B F D G
C J E V A
T
Priorité 4
(Priorité la plus basse)
Priorité 1
Priorité 2
Algo : tant que classe i non vide : tourniquet ; i=i-1;
Si les priorités ne sont pas ajustées de tps en tps, risque de famine de
CPU pour les processus de plus faible priorité
L’ordonnancement
du plus court d’abord [1]
Algorithme plus adapté au traitement par lots et pour lequel
les temps d’exécution sont connus à l’avance (ex :
sauvegarde hebdomadaire)
Idée : lorsque des travaux de même importance se trouvent
dans une file d’attente, l’ordonnanceur doit choisir le plus
court d’abord
Ex : 4 jobs A,B,C,D dont les tps sont 8,4,4,4 minutes
– exécution dans cet ordre : tps écoulé avant la fin d’exécution : 8
minutes pour A, 12 pour B, 16 pour C et 20 pour D Ämoyenne =
14 minutes
– exécution du plus court d’abord : tps écoulés : 4,8,12,20
Ämoyenne = 11 minutes !
L’ordonnancement
du plus court d’abord [3]
Estimation basée sur le comportement passé du processus
Soit T0 le tps estimé par une exec et T1 le tps suivant mesuré ; le tps
estimé = moyenne pondérée des 2 nombres : aT0+(1-a)T1
Pour a=½, les estimations successives sont :
T0, T0/2+T1/2, T0/4+T1/4+T2/2, T0/8+T1/8+T2/4+T3/2
Cette méthode d’estimation s’appelle le vieillissement (aging)
Stratégie du + court optimale uniquement si les travaux sont
disponibles simultanément :
Ex : 5 travaux (A à E) dont les tps sont 2,4,1,1 et 1 arrivent aux instants
0,0,3,3 et 3
– stratégie du + court (A,B,C,D,E) : attente moyenne = 32/5=6.4
– stratégie optimale (B,C,D,E,A) : attente moyenne = 31/5=6.2
2
L’ordonnancement garanti
Autre approche : garantir à l’utilisateur une certaine
performance
Promesse facile à tenir : n utilisateurs connectés, chaque
utilisateur reçoit 1/n de la puissance du CPU
Le système mémorise le tps CPU consommé par chaque
utilisateur et calcule le rapport entre le tps CPU consommé et
le tps CPU auquel un utilisateur a droit
L’algo consiste à choisir le processus qui a le plus faible
rapport jusqu’à ce que celui-ci dépasse celui du processus le
plus proche
Algo semblable appliqué aux systèmes tps réels où il faut
impérativement respecter des délais
Décision et mécanisme
Nous avons supposé jusqu’à présent que tous les processus été en
compétition, mais ceci est souvent inexact !
Ex : un processus serveur père qui délègue des tâches à ses fils,
certaines étant plus prioritaires
Aucun ordonnanceur n’acceptant de directives des processus,
l’ordonnanceur effectuera rarement le meilleur choix !
Solution séparer mécanisme et décision
Ex: le noyau utilise un ordonnancement avec priorité et fournit un appel
système permettant à un processus de modifier la priorité de ses fils
De cette manière, le père peut contrôler l’ordonnancement de ses fils
bien qu’il ne réalise pas l’ordonnancement
Le mécanisme est situé dans le noyau et les décisions sont prises par
les processus utilisateurs
L’ordonnancement à 2 niveaux [1]
Nous avons supposé jusqu’ici que tous les processus prêts se
trouvaient en mémoire
La mémoire centrale étant limitée, certains de ces processus devront
être gardés sur disque
Les conséquences sur l’ordonnancement sont importantes : tps de
commutation 2 à 3 fois + élevé
L’ordonnanceur à 2 niveaux facilite le traitement des processus
stockés sur disque :
– Un sous-ensemble des processus prêts est en mémoire
– L’ordonnanceur ne choisit pendant un moment que les processus de ce sousensemble
– Périodiquement, un ordonnanceur de plus haut niveau retire de la mémoire les
processus qui y sont restés assez longtemps et les remplace par des processus
qui sont sur disque depuis trop de tps
L’ordonnancement à 2 niveaux [2]
L’ordonnanceur de bas niveau choisit des processus en
mémoire alors que l’ordonnanceur de haut niveau se charge
du va-et-vient des processus entre la mémoire et le disque
Les critères suivants interviennent dans le choix de
l’ordonnanceur de haut niveau :
–
–
–
–
Depuis combien de tps un processus a-t-il été rapporté du disque ?
Combien de tps CPU le processus a-t-il eu récemment ?
Quelle est la taille du processus ? (les petits ne sont pas très gênants)
Quelle la priorité du processus ?
Pour cet ordonnanceur de haut niveau, il est possible
d’utiliser un des algos présentés
3