Vous êtes sur la page 1sur 22

Ordonnancement de processus

• Introduction

• Niveaux d’ordonnancement

• Objectifs d’ordonnancement

• Politiques d’ordonnancement

• Ordonnanceurs non préemptifs

• Ordonnanceurs préemptifs

• Etudes de cas
– Cas d’UNIX
– Cas de Linux
– Cas de Windows XP
– Implémentation : Ordonnanceur de Nachos

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.1

Introduction

• Les programmes lancés sont d’abord admis par le système qui se charge
d’en créer les processus nécessaires.

• Dans un système multiprogrammé, plusieurs processus peuvent être


présents en mémoire centrale.

• Le système d’exploitation décide de l’ordre et du moment de l’admission des


programmes en attente (ordonnanceur de haut niveau).

• Il gère également l’allocation du processeur aux différents processus à


exécuter (ordonnanceur de bas niveau).

• L’exécution d’un processus est une séquence alternée de calculs CPU


(rafales « burst ») et d’attentes d’événements (E/S, attente d’un
sémaphore..).

• Lorsque le processus en cours se bloque, le processeur est alloué à un autre


=> L’ordonnanceur de bas niveau se charge des changements de contexte.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.2

1
Introduction (2)
Commutation de contexte
Programme A Mode kernel Programme B
Mode utilisateur Mode utilisateur
exécution

Sauvegarder état dans PCB A

exécution
Charger état de PCB B

Sauvegarder état en PCB B

exécution Charger état de PCB A

• Pour accélérer la commutation, certains processeurs sont dotés de deux ou


plusieurs groupes de registres.
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.3

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

File d’attente, prêt hors mémoire

Ordonnancement
de niveau intermédiaire
File d’attente, attente hors mémoire

File d’attente, attente d’événement


Attente d’événement
Occurrence
d’événement
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.4

2
Niveaux d’ordonnancement (2)

• L’ordonnanceur de haut niveau décide du degré de la multiprogrammation (


nombre maximal de processus dans le système).

• L’ordonnanceur de niveau intermédiaire gère le déplacement des processus


d’une file d’attente à une autre.

• Dans la majorité des systèmes actuels, les niveaux intermédiaire et haut


sont combinés -> haut niveau.

• L’ordonnanceur de bas niveau (dispatcher ou répartiteur) est sollicité


plusieurs fois par seconde et doit constamment résider en mémoire.

• L’ordonnancement doit se faire selon une politique bien réfléchie visant à


répondre à des objectifs de performance.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.5

Objectifs d’ordonnancement

1. Maximiser le nombre de processus exécutés par unité de temps.

2. Minimiser le temps d’attente d’exécution de chaque processus.

3. Maximiser les temps d’utilisation des processeurs et autres ressources.

4. Respecter les échéanciers (terminer l’exécution avant leurs deadlines).

5. Éviter le problème de famine (attente infinie).

6. Favoriser les processus les plus prioritaires (éviter le problème d’inversion des
priorités).

7. Minimiser le nombre et la durée des changements de contexte.

Difficile de les satisfaire à la fois (exemple objectifs 1 et 4).


Prioriser les objectifs.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.6

3
Objectifs d’ordonnancement (2)
Critères de performances

• Temps de séjour d’un processus (temps de rotation ou de virement) : temps


entre l’admission du processus et sa sortie.

• Temps d' attente d’un processus : somme des périodes que le processus
passe à l'
état prêt

• Temps de réponse: temps qui s'


écoule entre l'
entrée d'
un processus
et le moment où il commence à être traité

• Capacité de traitement : nombre de processus traités par unité de temps.

• Taux d’utilisation d’un processeur.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.7

Politique d’ordonnancement

• Choix du processus à exécuter ?


– Premier arrivé, premier servi.
– Plus prioritaire (priorités statiques ou dynamiques).
– Plus court temps ….

• Le temps d’allocation du processeur au processus choisi :


– Allocation jusqu’à terminaison ou libération volontaire (ordonnanceur non
préemptifs).
– Temps d’allocation limité fixe ou variable (ordonnanceur préemptifs).

• Quand appeler l’ordonnanceur ?


– Le processus en cours se termine, se bloque ou cède le processeur,
– Le temps alloué a expiré.
– L’arrivée d’un processus plus prioritaire…

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.8

4
Ordonnanceurs non préemptifs
(sans réquisition)
• Le système d’exploitation choisit le prochain processus à exécuter :

– Premier arrivé, Premier servi (FCFS, First-Come First-Served) ou

– Plus court d’abord (SPF, Short Process First ou SJF Short Job First).

– Plus prioritaire d’abord (priorite = (temps d’attente + temps d’exécution) /


temps d’exécution).

• Il lui alloue le processeur jusqu’à ce qu’il se termine, se bloque (en


attente d’un événement) ou cède le processeur. Il n’y a pas de
réquisition.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.9

Ordonnanceurs non préemptifs (2)


FCFS
Processus Exécution Arrivée

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.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.10

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

Remarque : Meilleur temps moyen d’attente.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.11

Ordonnanceurs non préemptifs (4)


SPF

• Parmi les processus prêts, le processus élu est celui dont la prochaine
rafale est la plus courte.

Comment estimer le temps de la prochaine rafale ?


• Le temps de la prochaine rafale de chaque processus est estimé en se
basant sur le comportement passé du processus.

• Soient Si et Ti les temps d’exécution estimé et mesuré pour la iième rafale,


les estimations successives sont :
S0 ; pour la première
S1 = αT0 +(1- α )S0 ; pour la seconde
S2 = αT1 +(1- α )S1 ; pour la troisième
….
0≤α≤1

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.12

6
Ordonnanceur non préemptifs (5)
à priorité (éviter la famine)

Processus Exécution Arrivée

A 3 0

B 6 1

C 4 4

D 2 6

E 1 7

• Priorité = (temps d’attente + temps d’exécution) / temps d’exécution


• AAABBBBBBEDDCCCC
• Le temps moyen de séjour : 6,4
• Le temps moyen d’attente : 3,2

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.13

Ordonnanceurs avec réquisition


(préemptifs)

• Pour s’assurer qu’aucun processus ne s’exécute pendant trop de temps, les


ordinateurs ont une horloge électronique qui génère périodiquement une
interruption.

• A chaque interruption d’horloge, le système d’exploitation reprend la main et


décide si le processus courant doit :
– poursuivre son exécution ou
– être suspendu pour laisser place à un autre.

• S’il décide de suspendre l’exécution au profit d’un autre, il doit d’abord


sauvegarder l’état des registres du processeur avant de charger dans les
registres les données du processus à lancer (commutation de contexte).

• Cette sauvegarde est nécessaire pour pouvoir poursuivre ultérieurement


l’exécution du processus suspendu.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.14

7
Ordonnanceurs avec réquisition (2)
(préemptifs)

• Le processeur passe donc d’un processus à un autre en exécutant chaque


processus pendant quelques dizaines ou centaines de millisecondes.

• Le temps d’allocation du processeur au processus est appelé quantum.

• Cette commutation entre processus doit être rapide (temps nettement


inférieur au quantum).

• Le processeur, à un instant donné, n’exécute réellement qu’un seul


processus.

• Pendant une seconde, le processeur peut exécuter plusieurs processus et


donne ainsi l’impression de parallélisme (pseudo-parallélisme).

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.15

Ordonnanceurs préemptifs (3)


(Shortest Remaining Time SRT)

• Lorsqu’un processus arrive, l’ordonnanceur compare le temps estimé de


son exécution avec celle du processus actuellement en exécution
(version préemptive du SPF).
• Si ce temps est plus petit, on exécute immédiatement le nouveau
processus.
Processus Exécution Arrivée
AAABCCCCEDDBBBBB
A 3 0
Temps moyen de séjour : 5.8
Temps moyen d’attente : 2.6 B 6 1
Nombre de changements de contexte : 6
C 4 4

D 2 6

E 1 7

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.16

8
Ordonnanceurs préemptifs (4)
Ordonnancement circulaire (Tourniquet ou round robin)

• Algorithme ancien, simple, fiable et très utilisé.

• Il mémorise dans une file (FIFO : First In First Out), la liste des
processus en attente d’exécution (prêts).

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.17

Ordonnanceurs préemptifs (5)


Ordonnancement circulaire
Choix de la valeur du quantum
• Algorithme équitable mais sensible au choix du quantum.

• Un quantum trop petit provoque trop de commutations de


processus et abaisse l’efficacité du processeur.

• Un quantum trop élevé augmente le temps de réponse des


courtes commandes en mode interactif.

• Il était de 1 seconde dans les premières versions d’UNIX.

• Il varie entre 20 et 120 ms.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.18

9
Ordonnanceurs préemptifs (6)
Ordonnancement circulaire
Exemple 1

Processus Exécution Arrivée

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

Ordonnanceurs préemptifs (7)


Ordonnancement circulaire
Exemple 2
Quantum = 3 unités
Commutation de contexte = 1 unité

Processus Exécution Arrivée

A 8 0
B 5(2)3 3
C 4 7

• Le temps de séjour moyen : 21.33.


• Le temps moyen d’attente : 14
• Nombre de changements de contexte : 8

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.20

10
Ordonnanceurs préemptifs (8)
Ordonnancement circulaire
Exemple 3

Processus Exécution Arrivée


Quantum = 5 unités
Commutation de contexte = 1 unité A 8 0
B 5(2)3 3
C 4 4
Quantum = 5 unités

A A A A A B B B B B C C C C A A A B B B

• Le temps de séjour moyen : (21+22+13)/3 (soit 18,66).


• Le temps d’attente moyen : 11,33.
• Nombre de changements de contexte : 5

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.21

Ordonnanceurs préemptifs (9)


Ordonnancement circulaire
Exemple 4

Processus Exécution Arrivée


Quantum = 7 unités A 8 0
Commutation de contexte = 1 unité
B 5(2)3 3
C 4 4

Quantum = 7 unités

A A A A A A A B B B B B CC C C A B B B

• Le temps de séjour moyen : (21+22+15)/3 (soit 19.33).


• Le temps d’attente moyen : 8.
• Nombre de changements de contexte : 5

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.22

11
Ordonnanceurs préemptifs (10)
Ordonnanceur à priorité avec files multiples

• Il attribue une priorité à chaque processus (statique ou dynamique).

• Les processus de même priorité sont dans une file FIFO

• Il y a autant de files qu’il y a de niveaux de priorité

• Les processus de chaque file sont ordonnancés selon l’algorithme du


Tourniquet (Round Robin avec un quantum variable ou fixe) ou FCFS.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.23

Ordonnanceurs préemptifs (11)


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.

• Inversion des priorités :

– un processus moins prioritaire détient une ressource nécessaire


à l’exécution d’un processus plus prioritaire.

– Le processus moins prioritaire ne peut pas s’exécuter car il y a


constamment des processus actifs plus prioritaires.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.24

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.

• La priorité du processus en cours est comparée régulièrement à celle du


processus prêt le plus prioritaire (en tête de file). Lorsqu’elle devient
inférieure, la commutation a lieu.

• Dans ce cas, le processus suspendu est inséré en queue de file


correspondant à sa nouvelle priorité.

• 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.

• Pour éviter qu’il y ait beaucoup de commutations pour les processus


consommateurs de temps CPU, il est préférable d’allouer un plus grand
quantum à ces processus (quantum variable).
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.25

Etudes de cas

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.26

13
Cas d’UNIX (traditionnel)

• C’est un ordonnanceur à deux niveaux. L’ordonnanceur de bas niveau se


charge d’élire un processus parmi ceux qui résident en mémoire.

• L’ordonnanceur de haut niveau se charge des transferts de processus entre


la mémoire centrale et le disque.

• L’ordonnanceur de bas niveau utilise plusieurs files, une priorité est


associée à chaque file (plusieurs niveaux de priorité).

• Les processus prêts qui sont en mémoire, sont répartis dans les files selon
leur priorité.

• Les priorités des processus s’exécutant en mode utilisateur sont positives


ou nulles, alors que celles des processus s’exécutant en mode noyau sont
négatives.

• Les priorités négatives sont les plus élevées.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.27

Cas d’UNIX (traditionnel) (2)

• L’ordonnanceur de bas niveau choisit le processus le plus prioritaire


qui se trouve en tête de file.

• Le processus élu est alors exécuté pendant au maximum un


quantum (100 ms). S’il ne se termine pas ou ne se bloque pas au
bout de ce quantum, il est suspendu.

• Le processus suspendu est inséré en queue de sa file.

• La priorité initiale d’un processus utilisateur est en général égale à


0. La commande nice permet d’attribuer une priorité plus basse à un
processus (>0).

• Les priorités des processus prêts en mémoire sont recalculées


périodiquement toutes les secondes.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.28

14
CAS d’UNIX (traditionnel) (3)

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.29

Cas de Linux

• L’ordonnanceur de Linux est un ordonnanceur préemptifs et à priorité.

• Il distingue trois classes de tâches (processus) qu’il ordonnance différemment:

– Processus FIFO temps réel (les plus prioritaires) : Aucun processus de


cette classe ne peut être interrompu par un autre, à moins que ce soit un
processus plus prioritaire de la même classe.

– Processus Tourniquet temps réel.

– Processus Temps partagé (les moins prioritaires) : Ils s’exécutent


uniquement si aucun processus des classes 1 et 2 n’est prêt.

• Chaque processus créé fait partie d’une des trois classes et a une priorité
comprise entre 1 et 40 (20 par défaut).

• Les valeurs élevées correspondent à des priorités élevées.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.30

15
Cas de Linux (2)
• Chaque processus de la deuxième et troisième classe a un Quantum : valeur
initiale = priorité.

• Le Quantum du processus en cours d’exécution diminue de 1 unité à chaque


consommation de 10 ms de temps CPU.

• Les quanta sont réajustés lorsque tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité

• Lorsque l’ordonnanceur prend le contrôle, il attribue une note à chaque


processus :

Note = 1000 + priorité si le processus appartient aux classes temps-réel


Note = Quantum >0 ? Quantum + priorité : 0 sinon

• Le processus élu est celui qui a une plus forte note.

• Le temps d’allocation du processeur est au plus égal à 10 fois son Quantum.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.31

Cas de Linux (3)

Répéter
• Réajuster les quanta si tous les processus sont bloqués ou leurs
quanta sont nuls : Quantum = Quantum / 2 + priorité

• Calculer la note de chaque processus prêt :


Note = 1000 + priorité si le processus appartient aux classes temps-réel
Note = Quantum >0 ? Quantum + priorité : 0 sinon

• Allouer le processeur à celui qui a la plus grande note (temps


d’allocation maximun est 10 fois son quantum).

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.32

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.

Processus Nouveau quantum


A 4/2+20 = 22
B 14/2+18 = 25
C 0/2 +10 = 10

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.33

Cas de Linux (5)


Exemple
Processus Priorité Exécution (ms)

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).

Processus Note Quantum


A 42 22
B 43 25
C 0 10

• B s'exécute et se termine au bout de 140 ms (250-140 ms non utilisées).


• A s'exécute et se termine au bout de 70 ms.
• C s’exécute et se termine au bout de 100 ms.
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.34

17
Cas de Windows XP

• Windows XP ne contient pas un module autonome qui se charge de l’ordonnancement.


Le code est dispersé.

• Il ordonnance les threads sans se préoccuper de leurs processus.

• C’est un ordonnanceur préemptif à priorité (32 niveaux de priorité). Les priorités sont
dynamiques.

• On distingue quatre classes de processus légers :


– Les threads temps réel : chaque thread de cette classe a une priorité comprise
entre 16 et 31. Sa priorité ne change jamais.
– Les threads utilisateur : chaque thread de cette classe a une priorité comprise
entre 1 et 15. Sa priorité varie durant sa vie mais reste toujours comprise entre 1 et
15. Il migre d’une file à une autre avec l’évolution de sa priorité.
– Le thread zéro (priorité 0) : il s’exécute, en arrière plan, lorsque toutes les files, de
priorité supérieure, sont vides. Il se charge de la remise à zéro des pages libérées.
– Le thread idle : il s’exécute si toutes les files sont vides.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.35

Cas de Windows XP (2)

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.36

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 est appelé si :


– Un thread passe à l’état prêt ou quitte l’état d’exécution.
– La priorité ou l’affinité de processeur d’un thread change.

• 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.

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.37

Cas de Windows XP (4)


• Si un thread à l’état prêt reste trop longtemps en attente du processeur (depuis 4
secondes environ), il se voit attribuer une priorité 15 et un quantum de 4 unités
(accélérer le threads pour éviter le problème de famine).

• À la fin du quantum, le thread reprend sa priorité de base originale.

• C’est le « balance set manager » qui se charge de la recherche de tels threads


(toutes les secondes).

• Afin de minimiser le temps CPU consommé par le balance set manager, au


maximum 16 threads sont examiné à chaque passage. S’il y en a plus, il examinera
les 16 suivants à son prochain passage.

• Le balance set manager limite le nombre de threads à accélérer à 10.

• Un changement de contexte se produit à chaque ordonnancement et exige que l’on


mémorise :
– Pointeur d’instruction (compteur ordinal)
– Pointeurs de pile utilisateur et de pile noyau
– Pointeur vers l’espace d’adressage dans lequel est exécuté le thread (répertoire
des tables de pages du processus).

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.38

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

void ReadyToRun(Thread* thread); // Thread can be dispatched.


Thread* FindNextToRun(); // Dequeue first thread on the ready list, if any, and return thread.
void Run(Thread* nextThread, bool finishing); // Cause nextThread to start running
void CheckToBeDestroyed(); // Check if thread that had been running needs to be deleted
void Print(); // Print contents of 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

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.39

Implémentation
Ordonnanceur Nachos (2)

Scheduler::Scheduler()
{ readyList = new List<Thread *>;
toBeDestroyed = NULL;
}

Scheduler::~Scheduler()
{ delete readyList;
}

void Scheduler::ReadyToRun (Thread *thread)


{
ASSERT(kernel->interrupt->getLevel() == IntOff);
DEBUG(dbgThread, "Putting thread on ready list: " << thread->getName());
thread->setStatus(READY);
readyList->Append(thread);
}

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.40

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);
}

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.41

Implémentation
Ordonnanceur Nachos (4)

void Scheduler::Run (Thread *nextThread, bool finishing)


{ Thread *oldThread = kernel->currentThread;

ASSERT(kernel->interrupt->getLevel() == IntOff);

if (finishing) { // mark that we need to delete current thread


ASSERT(toBeDestroyed == NULL);
toBeDestroyed = oldThread;
}

#ifdef USER_PROGRAM // ignore until running user programs


if (oldThread->space != NULL) { // if this thread is a user program,
oldThread->SaveUserState(); // save the user' s CPU registers
oldThread->space->SaveState();
}
#endif

oldThread->CheckOverflow(); // check if the old thread had an undetected stack overflow

Systèmes d’exploitation Génie Informatique


École Polytechnique de Montréal Chapitre 7.42

21
Implémentation
Ordonnanceur Nachos (5)
kernel->currentThread = nextThread; // switch to the next thread
nextThread->setStatus(RUNNING); // nextThread is now running

// This is a machine-dependent assembly language routine defined in switch.s.


SWITCH(oldThread, nextThread);

// interrupts are off when we return from switch!


ASSERT(kernel->interrupt->getLevel() == IntOff);

CheckToBeDestroyed(); // check if thread we were running


// before this one has finished
// and needs to be cleaned up
#ifdef USER_PROGRAM
if (oldThread->space != NULL) { // if there is an address space
oldThread->RestoreUserState(); // to restore, do it.
oldThread->space->RestoreState();
}
#endif
}
Systèmes d’exploitation Génie Informatique
École Polytechnique de Montréal Chapitre 7.43

22