Professional Documents
Culture Documents
• Introduction
• Niveaux d’ordonnancement
• Objectifs d’ordonnancement
• Politiques d’ordonnancement
• Ordonnanceurs préemptifs
• Etudes de cas
– Cas d’UNIX
– Cas de Linux
– Cas de Windows XP
– Implémentation : Ordonnanceur de Nachos
Introduction
• Les programmes lancés sont d’abord admis par le système qui se charge
d’en créer les processus nécessaires.
1
Introduction (2)
Commutation de contexte
Programme A Mode kernel Programme B
Mode utilisateur Mode utilisateur
exécution
exécution
Charger état de PCB B
Niveaux d’ordonnancement
Ordonnancement Expiration
de haut niveau
Ordonnancement
Lot de travaux en attente d’admission de bas niveau
File d’attente, prêt Terminé
Processeur
Process eur
Ordonnancement
de niveau intermédiaire
Ordonnancement
de niveau intermédiaire
File d’attente, attente hors mémoire
2
Niveaux d’ordonnancement (2)
Objectifs d’ordonnancement
6. Favoriser les processus les plus prioritaires (éviter le problème d’inversion des
priorités).
3
Objectifs d’ordonnancement (2)
Critères de performances
• Temps d' attente d’un processus : somme des périodes que le processus
passe à l'
état prêt
Politique d’ordonnancement
4
Ordonnanceurs non préemptifs
(sans réquisition)
• Le système d’exploitation choisit le prochain processus à exécuter :
– Plus court d’abord (SPF, Short Process First ou SJF Short Job First).
A 3 0
B 6 1
C 4 4
D 2 6
E 1 7
AAABBBBBBCCCCDDE
Temps de séjour moyen : 7.6
Temps moyen d’attente : 4.4
Nombre de changements de contexte : 5
Remarque :
Temps moyen d’attente élevé si de longs processus sont exécutés en premier.
5
Ordonnanceurs non préemptifs (3)
Short Processus First (SPF ou SJF)
Processus Exécution Arrivée
A 3 0
B 6 1
C 4 4
D 2 6
E 1 7
AAABBBBBBEDDCCCC
Temps de séjour moyen : 6.4
Temps moyen d’attente : 3.2
Nombre de changements de contexte : 5
• Parmi les processus prêts, le processus élu est celui dont la prochaine
rafale est la plus courte.
6
Ordonnanceur non préemptifs (5)
à priorité (éviter la famine)
A 3 0
B 6 1
C 4 4
D 2 6
E 1 7
7
Ordonnanceurs avec réquisition (2)
(préemptifs)
D 2 6
E 1 7
8
Ordonnanceurs préemptifs (4)
Ordonnancement circulaire (Tourniquet ou round robin)
• Il mémorise dans une file (FIFO : First In First Out), la liste des
processus en attente d’exécution (prêts).
9
Ordonnanceurs préemptifs (6)
Ordonnancement circulaire
Exemple 1
A 3 0
Quantum = 1
Temps de commutation = 0 B 6 1
C 4 4
D 2 6
E 1 7
ABABACBDCEBDCBCB
Temps moyen de séjour : 8,0
Temps moyen d’attente : 4,8
Nombre de changements de contexte : 16
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.19
A 8 0
B 5(2)3 3
C 4 7
10
Ordonnanceurs préemptifs (8)
Ordonnancement circulaire
Exemple 3
A A A A A B B B B B C C C C A A A B B B
Quantum = 7 unités
A A A A A A A B B B B B CC C C A B B B
11
Ordonnanceurs préemptifs (10)
Ordonnanceur à priorité avec files multiples
Problèmes
• Équité : L’exécution des processus moins prioritaires peut
être constamment retardée par l’arrivée de processus plus
prioritaires.
12
Ordonnanceurs préemptifs (12)
Ordonnanceur à priorité avec files multiples
Attribution et évolution des priorités
• Pour empêcher les processus de priorité élevée de s’exécuter indéfiniment,
l’ordonnanceur diminue régulièrement la priorité du processus en cours
d’exécution (priorité dynamique) et augmente progressivement celles des
processus en attente.
• Pour favoriser les processus qui font beaucoup d’E/S, ils doivent acquérir le
processeur dès qu’ils le demandent, afin de leur permettre de lancer leurs
requêtes suivantes d’E/S.
Etudes de cas
13
Cas d’UNIX (traditionnel)
• Les processus prêts qui sont en mémoire, sont répartis dans les files selon
leur priorité.
14
CAS d’UNIX (traditionnel) (3)
Cas de Linux
• Chaque processus créé fait partie d’une des trois classes et a une priorité
comprise entre 1 et 40 (20 par défaut).
15
Cas de Linux (2)
• Chaque processus de la deuxième et troisième classe a un Quantum : valeur
initiale = priorité.
• Les quanta sont réajustés lorsque tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité
Répéter
• Réajuster les quanta si tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité
16
Cas de Linux (4)
Exemple
Processus Priorité Exécution
A 20 160 (180) 70
B 18 40 (150) 140
C 10 300
• A s'
exécute et s'interrompt après 160 ms (40 ms non utilisées).
• B s'
exécute et s'
interrompt après 40 ms (140 ms non utilisées).
• C s'
exécute pendant 100 ms et est interrompu, A et B toujours bloqués.
A 20 160 (180) 70
B 18 40 (150) 140
C 10 300
• C s'
exécute à nouveau et est interrompu (sa note est 0).
17
Cas de Windows XP
• C’est un ordonnanceur préemptif à priorité (32 niveaux de priorité). Les priorités sont
dynamiques.
18
Cas de Windows XP (3)
• Les processus légers de même priorité sont dans une même file et ordonnancés
selon l’algorithme du tourniquet.
• L’ordonnanceur choisit le processus léger le plus prioritaire en tête de file et lui alloue
le processeur pendant au maximum un quantum.
• Quand un processus léger est sélectionné, son exécution peut être interrompue
(avant la fin du quantum) si un autre processus léger de priorité plus élevée devient
prêt. Le thread préempté est remis en tête de la file associée à son niveau de
priorité.
• Si un thread est suspendu car il a consommé son quantum, sa priorité peut être
diminuée.
• S’il est interrompu pour une requête d’E/S, un sémaphore, etc., son quantum est
décrémenté par contre sa priorité augmente. Elle augmente encore plus, s’il s’agit
d’une requête d’E/S qui concerne un clavier ou un écran.
19
Implémentation
Ordonnanceur Nachos
#ifndef SCHEDULER_H
#define SCHEDULER_H
class Scheduler {
public:
Scheduler(); // Initialize list of ready threads
~Scheduler(); // De-allocate ready list
private:
List<Thread *> *readyList; // queue of threads that are ready to run but not running
Thread *toBeDestroyed; // finishing thread to be destroyed
// by the next thread that runs
};
#endif // SCHEDULER_H
Implémentation
Ordonnanceur Nachos (2)
Scheduler::Scheduler()
{ readyList = new List<Thread *>;
toBeDestroyed = NULL;
}
Scheduler::~Scheduler()
{ delete readyList;
}
20
Implémentation
Ordonnanceur Nachos (3)
Thread * Scheduler::FindNextToRun ()
{ ASSERT(kernel->interrupt->getLevel() == IntOff);
if (readyList->IsEmpty()) return NULL;
else return readyList->RemoveFront();
}
void Scheduler::CheckToBeDestroyed()
{ if (toBeDestroyed != NULL)
{ delete toBeDestroyed;
toBeDestroyed = NULL;
}
}
void Scheduler::Print()
{ cout << "Ready list contents:\n";
readyList->Apply(ThreadPrint);
}
Implémentation
Ordonnanceur Nachos (4)
ASSERT(kernel->interrupt->getLevel() == IntOff);
21
Implémentation
Ordonnanceur Nachos (5)
kernel->currentThread = nextThread; // switch to the next thread
nextThread->setStatus(RUNNING); // nextThread is now running
22