Chapitre 2 Gestion du Processeur 1

Chapitre 2
Gestion du
Processeur
1 Introduction ............................................................................................................................................. 2
2 Notions de base ....................................................................................................................................... 2
2.1 Ressource ......................................................................................................................................... 2
2.2 Programme ...................................................................................................................................... 2
2.3 Job ........................................................................................................................................................ 2
2.4 Processus .......................................................................................................................................... 2
2.5 Thread................................................................................................................................................ 2
3 Les Processus ........................................................................................................................................... 3
3.1 Les différents états d’un processus ........................................................................................ 3
3.2 Espace Mémoire alloué à un processus ................................................................................ 4
3.3 Contexte d’un processus ............................................................................................................. 4
3.4 Commutation de Contexte ......................................................................................................... 4
3.5 Opérations sur les processus .................................................................................................... 5
3.6 Hiérarchie des processus ........................................................................................................... 5
3.7 Relations entre les processus ................................................................................................... 5
4 Généralités sur l’ordonnancement des processus .................................................................... 6
4.1 Définition .......................................................................................................................................... 6
4.2 Cycle CPU –Cycle E/S ................................................................................................................... 6
4.3 Ordonnancement préemptif ou non préemptif ................................................................. 6
4.4 Files d’attente de l’ordonnancement ..................................................................................... 6
4.5 Evaluation de la performance de l’ordonnancement ...................................................... 6
5 Algorithmes d’ordonnancement ...................................................................................................... 7
5.1 Ordonnancement FIFO (First In First Out).......................................................................... 7
5.2 Ordonnancement SJF (Shortest Job First) .......................................................................... 7
5.3 Ordonnancement SRTJF (Shortest Remaining Time First) ......................................... 8
5.4 Ordonnancement par priorité .................................................................................................. 8
5.5 Ordonnancement cyclique ......................................................................................................... 9
5.6 Ordonnancement avec des files d’attente multi-niveaux (Multilevel Queue MLQ)
10
5.7 Ordonnancement avec des files d’attente multi-niveaux feedback (MLFQ :
Multilevel Feed-back Queues) ............................................................................................................. 10
6 Cas Pratiques : Unix et Windows ................................................................................................... 11
6.1 Ordonnancement dans le système Unix ............................................................................. 12
6.2 Ordonnancement dans le système Windows ................................................................... 12

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 2

1 Introduction
L’objectif de ce chapitre est de présenter les principes de base utilisés par le système
d’exploitation dans la gestion du processeur. On étudiera les algorithmes
d’ordonnancement appliqués dans la majorité des S.E, on donnera des cas concrets sur
les systèmes Unix et Windows.

2 Notions de base
2.1 Ressource
Une ressource dans un système informatique signifie tout composant physique ou
logique de disponibilité limitée (Périphérique connecté, Processeur, M.C, Fichier,
Connexion réseau, etc. .... ).

2.2 Programme

Un Programme est une suite d’instructions séquentielles qui peut être en langage
évolué, objet ou exécutable. Il est stocké sur le disque.

Processus
Programme
Programme
en Code Compilation Programme Edition Chargement en
source Objet de liens Exécutable M.C et Exécution
par le CPU

Figure 2.1 : Etapes de Cheminement d’un programme dans un système

2.3 Job

Un Job est un programme soumis à la machine par l’utilisateur (lancé). Il peut être
admis (on lui alloue toutes les ressources nécessaires à son exécution comme l’espace
mémoire) et devient alors un processus.

2.4 Processus

Un processus est un programme en exécution. Le code et les données sont chargés en

M.C, et les instructions sont exécutées séquentiellement par le processeur.
Usuellement, un processus possède un seul thread de contrôle, c.-à-d. un seul ensemble
d’instructions machine s’exécutant à un instant donné. Il peut aussi avoir plusieurs flux
d’exécution (multi-thread).

2.5 Thread

Thread (processus léger) est un sous ensemble d’instructions séquentiel à l’intérieur

d'un processus. Plusieurs threads peuvent s’exécuter en même temps (en concurrence
sur une machine monoprocesseur, en parallèle sur une machine multiprocesseur)
comme par exemple l’éditeur de texte Word ayant deux threads : un qui contrôle la
saisie, et un autre thread qui effectue l’enregistrement automatique périodique (figure
2.2). L’approche des threads présente plusieurs avantages :

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 3

- Dans beaucoup d’applications, plusieurs tâches sont effectuées simultanément ce

qui permet un pseudo-parallélisme (chevauchement entre les tâches), en offrant
plus de gain en temps d’exécution.
- Les threads partagent des ressources comme l’espace mémoire.
- Les threads sont plus rapides à créer et à détruire (processus légers).
- Les threads sont utiles dans les systèmes multiprocesseurs (parallélisme)

Le Processus Word

Thread1 Thread2
Saisie Enregistrement
automatique

Document

Figure 2.2 : Exemple d’un processus multi-thread

3 Les Processus
3.1 Les différents états d’un processus
L’état d’un processus détermine sa situation dans le système, vis à vis de ses ressources.
Durant son exécution, un processus (ou thread) peut être dans un de ces cinq états :

 Nouveau : Le processus est créé par le système

 Prêt : Le processus attend la libération du processeur pour s’exécuter
 Actif : Le processus est en exécution
 Bloqué : Le processus attend une ressource physique ou logique autre que le
processeur pour s’exécuter (fin d’E/S, ...)
 Fin : Le processus termine son exécution et attend d’être déchargé de la M.C

Nouveau 2 Terminé

Prêt Exécution

3
4 1
Bloqué

Figure 2.3 : Etats d’un processus

Les transitions possibles entre ces différents états sont illustrées dans la figure 2.3:
1) Le processus est bloqué à cause d’une E/S
2) Le CPU exécute un autre processus
3) Le CPU reprend le processus
4) L’E/S est disponible

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

 Chapitre 2 Gestion du Processeur 4

3.2 Espace Mémoire alloué à un processus

La disposition typique de l’espace mémoire alloué au processus contient les parties

suivantes : Code, Données, Pile et Tas (Figure 2.4).

Pile Zone pour stocker les variables temporaires: locales, paramètres de fonctions, ...
Tas Zone d’allocation dynamique
Données Zone pour stocker les variables globales et statiques
Code Zone pour stocker le code exécutable
Figure 2.4: Espace mémoire alloué à un processus

3.3 Contexte d’un processus

Le contexte d’un processus est l’ensemble d’informations nécessaires à l’exécution d’un
programme en cours où à sa poursuite dans le cas où il a été interrompu. Le contexte du
processus en cours d’exécution représente aussi le contexte courant du CPU.
Le S.E maintient les informations relatives à chaque processus dans une «table de
processus» avec une entrée par processus (entrée = Process Control Bloc PCB). Chaque
entrée 𝑖 dans la table contient des informations importantes sur l’état du processus 𝑃𝑖
comme par exemple Contenu du registre Compteur Ordinal et l’adresse vers l’espace
d’adressage du processus. Le PCB contient toutes les informations qui doivent être
sauvegardées lorsque le processus passe de l’état «Exécution» vers l’état «Prêt» ou
«bloqué» afin qu’il puisse être exécuté ultérieurement.

PCB du PID C.O PSW Etat Priorité Instant du début Temps @ @ @ ....
processus d’exécution du CPU Pile Code Tas
processus utilisé

Figure 2.5 : Informations typiques contenues dans l’entrée d’une table de processus

3.4 Commutation de Contexte

La commutation de contexte consiste à passer d’un contexte d’un processus P1 à un
autre contexte d’un autre processus P2. Les raisons principales du changement de
contexte sont :
 La multiprogrammation : Redonner le contrôle du CPU au processus P2 à la place
du processus en cours P1. Le contexte de P1 est sauvegardé tandis que le contexte de
P2 est chargé.
 Interruption matérielle ou logicielle : La commutation de contexte peut être
déclenchée par un évènement d’origine matérielle telle qu’une Fin d’E/S, ou bien par
un évènement d’origine logicielle telle qu’une demande de lecture d’un fichier.
Le schéma suivant (figure 2.6) montre les étapes typiques dans une opération de
commutation de contexte.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 5

Sauvegarder le contexte de P1
P1

Changer l’état dans le PCB de P1 à Prêt/Bloqué

Un évènement Déplacer le PCB de P1 dans la file d’attente adéquate

qui déclenche la
commutation de
contexte Sélectionner un autre processus P2 pour exécution et
P2 changer l’état dans le PCB de P2 à «Exécution»

Restaurer le contexte du processeur

Continuer P1

Figure 2.6 : Etapes générales dans l’opération de commutation de contexte

3.5 Opérations sur les processus

Plusieurs opérations sont appliquées sur un processus :

 Création : consiste à lui donner un PID, créer son PCB et l’ajouter dans la file
d’attente des processus prêts
 Suspendre un processus : consiste à faire passer le processus de l’état «exécution» à
l’état «prêt». Son exécution est interrompue et son PCB actuel (contexte) est
sauvegardé.
 Terminer un processus : Les ressources dont il disposait sont libérées (mémoire,
périphériques, fichiers, ..), et son PCB est supprimé.

3.6 Hiérarchie des processus

Dans certains systèmes, un processus peut créer un autre et devenir son père. On
obtiendra une hiérarchie de processus qui permet une coopération entre les processus
fils et les processus pères. Cette approche est utilisée dans le système UNIX (cf. Chapitre
4).

3.7 Relations entre les processus

En mode multiprogrammé, plusieurs processus sont chargés en mémoire centrale et

exécutés en concurrence par le processeur. Deux types de relations peuvent exister
entre ces processus : Indépendance ou Coopération.

 Relation d’indépendance : Le processus est indépendant par rapport aux autres

processus s’exécutant en concurrence s’il n'affecte pas et ne peut pas être affecté par
d'autres processus en cours d'exécution. Les processus indépendants ne peuvent
partager aucune donnée.
 Relation de coopération : les processus en coopération peuvent être affectés
mutuellement lors de leurs exécutions. Ces processus peuvent partager des données
(exp. un processus P1 qui écrit sur un fichier F et un processus P2 qui lit le fichier F)

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 6

4 Généralités sur l’ordonnancement des processus

4.1 Définition
L’ordonnancement de processus est la sélection du S.E d’ un processus à exécuter par le
CPU. Il est utilisé dans les systèmes multiprogrammés : chaque fois que le CPU devient
inactif, le SE doit choisir un processus à exécuter dans la file des processus en état prêt.
4.2 Cycle CPU –Cycle E/S
L’exécution d’un processus est généralement une alternance entre des calculs « cycle
CPU » et des lecture-écriture « cycle E/S ». L’ordonnancement concerne essentiellement
les cycles CPU.
4.3 Ordonnancement préemptif ou non préemptif
L’ordonnancement peut être préemptif (avec réquisition) ou non préemptif (sans
réquisition).
 Ordonnancement non préemptif
Une fois que le CPU a été alloué à un processus, le processus garde le CPU jusqu’à ce qu’il
la libère, soit parce qu’il a terminé soit parce qu’il commute à l’état en attente (bloqué).
 Ordonnancement préemptif
Avant sa terminaison, le processus en exécution peut se remettre en file d’attente des
processus prêts car un autre processus lui réquisitionne le CPU (plus prioritaire,
nécessite moins de temps, .... etc.).
Si l'ordonnancement est non préemptif, la transition de l'état actif vers l'état prêt est
interdite: un processus quitte le processeur si il a terminé son exécution ou s’il se
bloque. Si l'ordonnancement est préemptif, la transition de l'état actif vers l'état prêt est
autorisée: un processus quitte le processeur s’il a terminé son exécution, s’il se bloque
ou si le processeur est réquisitionné.

4.4 Files d’attente de l’ordonnancement

 File d’attente des jobs
Dès l’arrivée d’un nouveau processus dans le système, il est introduit dans la file
d’attente des jobs (travaux).
 File d’attente des processus prêts
Les processus qui résident en MC et qui ont toutes les ressources nécessaires pour
s’exécuter excepté le CPU sont introduits dans la file d’attente des processus prêts.
 File d’attente des E/S
Quand un processus est interrompu pour une E/S, il doit attendre dans la file d’attente
du périphérique concerné (disque, terminal, ....). Chaque périphérique possède sa propre
file d’attente.
4.5 Evaluation de la performance de l’ordonnancement

Plusieurs critères peuvent être utilisés pour évaluer la performance d’un algorithme
d’ordonnancement, on cite comme exemple :

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 7

 Temps d’Exécution : C’est la somme des cycles du CPU :

𝑇𝑒𝑚𝑝𝑠 𝑑’𝑒𝑥é𝑐𝑢𝑡𝑖𝑜𝑛 = ∑ 𝑇𝑒𝑚𝑝𝑠 𝐶𝑃𝑈
 Temps de Restitution: intervalle entre le moment de soumission du job et le
moment de sa terminaison :
𝑇𝑒𝑚𝑝𝑠 𝑑𝑒 𝑅𝑒𝑠𝑡𝑖𝑡𝑢𝑡𝑖𝑜𝑛 = 𝐼𝑛𝑠𝑡𝑎𝑛𝑡 𝑑𝑒 𝐹𝑖𝑛 𝑑 ′ 𝐸𝑥é𝑐𝑢𝑡𝑖𝑜𝑛 − 𝐼𝑛𝑠𝑡𝑎𝑛𝑡 𝑑′𝑎𝑟𝑟𝑖𝑣é𝑒
 Temps d’Attente : la somme des temps passés à attendre dans la file d’attente des
processus prêts : C’est la différence entre le temps de Restitution et le temps
d’exécution total, c.-à-d ∑ 𝑇𝑒𝑚𝑝𝑠 𝐶𝑃𝑈 + ∑ 𝑇𝑒𝑚𝑝𝑠 𝐸/𝑆 :
𝑇𝑒𝑚𝑝𝑠 𝑑 ′ 𝐴𝑡𝑡𝑒𝑛𝑡𝑒 = 𝑇𝑒𝑚𝑝𝑠 𝑑𝑒 𝑅𝑒𝑠𝑡𝑖𝑡𝑢𝑡𝑖𝑜𝑛 − 𝑇𝑒𝑚𝑝𝑠 𝑑 ′ 𝑒𝑥é𝑐𝑢𝑡𝑖𝑜𝑛 𝑡𝑜𝑡𝑎𝑙
 Rendement du CPU : représente le taux d’occupation du processeur.
 Equité : mesure si les processus se partagent « à part égale » le temps processeur.

5 Algorithmes d’ordonnancement
5.1 Ordonnancement FIFO (First In First Out)
C’est un algorithme simple à implémenter basé sur la stratégie «premier arrivé, premier
servi».

Algorithme de principe FIFO

Entrée : File d’attente des processus prêts FAPP
Sortie : processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état bloqué
Alors l’ajouter en fin de la FAPP
#Sélection du processus
Sélectionner le processus en tête de la FAPP et l’exécuter jusqu’à
sa fin ou son passage à l’état bloqué (sans réquisition)

5.2 Ordonnancement SJF (Shortest Job First)

On suppose que le cycle CPU prochain du processus est connu d’avance. Le processus
qui nécessite le plus court cycle CPU est alors sélectionné. Dans le cas d’égalité, on utilise
généralement la stratégie FIFO.

Algorithme SJF
Entrée : File d’attente des processus prêts FAPP, Temps d’exécution
des processus
Sortie : Processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état bloqué
Alors l’ajouter à la FAPP associé à son prochain cycle CPU
#Sélection du processus
Sélectionner le processus dont le prochain cycle CPU est minimal et
l’exécuter jusqu’à sa fin ou son passage à l’état bloqué.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 8

5.3 Ordonnancement SRTJF (Shortest Remaining Time First)

C’est la version préemptive de l’algorithme SJF: Quand un nouveau processus arrive, son
temps CPU est comparé au temps restant du processus en cours. Si le nouveau processus
nécessite moins de temps que le processus en cours, le processus en cours est suspendu
pour permettre l’exécution du nouveau processus.

Algorithme SRTF
Entrée : File d’attente des processus prêts FAPP, Temps d’exécution
des processus
Sortie : Processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état bloqué
ou de l’état Exécution (suspendu)
Alors l’ajouter à la FAPP associé au temps de son prochain cycle CPU
#Sélection du processus
Si La FAPP contient un processus dont le temps CPU demandé < temps
restant du processus en cours
Alors
Suspendre le processus en cours (le mettre à l’état Prêt)
supprimer de la FAPP le processus sélectionné et l’exécuter jusqu’à
sa fin, ou son passage à l’état bloqué, ou jusqu’à l’arrivée dans la
FAPP d’un nouveau processus dont le temps CPU demandé < temps
restant du processus en cours.

5.4 Ordonnancement par priorité

Le SE associe à chaque processus une valeur qui désigne sa priorité. Le processus le
plus prioritaire est sélectionné d’abord. La priorité peut être statique ou dynamique
(change au cours du temps).

 Priorités statiques
Les priorités assignées d’une façon statique peuvent générer le problème de «Famine» :
Un processus de faible priorité peut attendre infiniment à cause de la présence d’autres
processus toujours plus prioritaires.
 Priorités dynamiques
Une solution commune au problème de famine consiste à assigner des priorités
dynamiques en se basant sur le principe de «vieillissement» : les priorités des processus
augmentent avec l’augmentation du temps d’attente. Un processus peu prioritaire aura
éventuellement sa priorité suffisamment élevée pour pouvoir être exécuté.
L’approche par priorité peut être préemptive ou non préemptive. Dans le cas non
préemptif, le processus le plus prioritaire est exécuté jusqu’à sa fin ou son passage à
l’état bloqué.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 9

Algorithme Par Priorité non préemptive

Entrée : File d’attente des processus prêts FAPP, Priorités des
processus
Sortie : Processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état bloqué
Alors l’ajouter à la FAPP associé à sa priorité
#Sélection du processus
Sélectionner le processus dont la priorité est maximale et
l’exécuter jusqu’à sa fin ou son passage à l’état bloqué.

Si l’algorithme est préemptif, la priorité du processus en cours est comparée à celle des
processus nouvellement arrivés dans la FAPP. Si elle est inférieur, le processus en cours
est suspendu pour permettre l’exécution du nouveau processus.

Algorithme Par Priorité préemptive

Entrée : File d’attente des processus prêts FAPP, Priorités des

processus
Sortie : Processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état bloqué
ou de l’état Exécution
Alors l’ajouter à la FAPP
#Sélection du processus
Si La FAPP contient un processus plus prioritaire que le processus
en cours
Alors
Suspendre le processus en cours (le mettre à l’état Prêt) ;
Sélectionner le processus et l’exécuter jusqu’à sa fin, ou son
passage à l’état bloqué, ou jusqu’à l’arrivée dans la FAPP d’un
nouveau processus plus prioritaire.

5.5 Ordonnancement cyclique (Round Robin)

La file des processus prêts est traitée comme une file FIFO circulaire : On attribue à
chaque processus une tranche de temps «quantum» après laquelle il se remet à la fin de
la FAPP. Si le processus courant libère le CPU et il n’est pas encore terminé, alors il se
met en queue de la file des prêts. Si le processus est bloqué ou terminé avant que le
quantum soit écoulé, une commutation de contexte est effectuée.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 10

Algorithme cyclique
Entrée : File d’attente des processus prêts FAPP, Q valeur du
Quantum
Sortie : Processus sélectionné pour exécution
#Gestion de la FAPP
Si un nouveau processus arrive de l’état nouveau ou de l’état
bloqué ou de l’état Exécution (fin de quantum)
Alors l’ajouter à la fin de la FAPP
#Sélection du processus
Suspendre le processus en cours (le mettre à l’état Prêt) s’il n’a
pas terminé son cycle CPU ;
Sélectionner le processus en tête de la FAPP et l’exécuter pendant
Q unités de temps au maximum.

5.6 Ordonnancement avec des files d’attente multi-niveaux (Multilevel

Queue MLQ)

La file d’attente des processus prêts est découpée en plusieurs files séparées, en se
basant sur certaines propriétés comme : le type du processus (système/utilisateur,
premier plan/ arrière plan, ....), la taille de la mémoire utilisée,.... etc. Chaque file possède
une priorité et son propre algorithme d’ordonnancement
Si on considère qu’on dispose de n files d’attentes Fi de priorités i (i = 1. . n) avec i = 1
la plus grande priorité, l’algorithme MLQ consiste à sélectionner un processus de la file
la plus prioritaire en appliquant l’algorithme associé à celle ci. Un processus d’une file Fi
de priorité i ne sera sélectionné pour exécution que si toutes les files plus prioritaires
soient vides. L’approche MLQ peut être préemptive ou non préemptive.

5.7 Ordonnancement avec des files d’attente multi-niveaux feedback

(MLFQ : Multilevel Feed-back Queues)

L’approche MLFQ est une version modifiée de la méthode MLQ qui autorise un
changement dynamique des priorités. Ceci permet aux processus de se déplacer entre
les files d’attente en fonction de l’évolution de leurs caractéristiques dans le système.
MLFQ utilise généralement les paramètres suivants :
 Le nombre de file d’attentes
 L’algorithme d’ordonnancement pour chaque file
 La méthode utilisée pour choisir la file d’attente où un nouveau processus est inséré
 La méthode utilisée pour déplacer un processus vers la file de priorité supérieure
 La méthode utilisée pour déplacer un processus vers la file de priorité inférieure

MLFQ permet généralement de produire de bonnes performances pour les jobs courts
interactifs (Ceci est réalisé « théoriquement » dans SJF et SRTF) et aussi les jobs longs
ne seront pas pénalisés. Le schéma de la figure 2.7 montre un exemple où on utilise trois
files d’attente chacune gérée par la stratégie cyclique.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

 Chapitre 2 Gestion du Processeur 11

Bloqué
F1 CPU
Terminaison
Fin Quantum
ntum
Bloqué
F2 CPU
Terminaison
Fin Quantum
ntum
Bloqué
F3 CPU
Terminaison
Fin Quantum
ntum
Figure 2.7 : Schéma général de l’algorithme MLFQ

L’exemple suivant montre un cas possible pour les choix des paramètres :
 Nombre de files d’attentes: Les processus prêts sont rangés dans 𝑛 files:
𝐹1, 𝐹2, . . . , 𝐹𝑛.
 La méthode utilisée pour choisir la file d’attente où un nouveau processus est
inséré : Un nouveau processus est inséré à la fin de la file la plus prioritaire 𝐹1
 L’algorithme d’ordonnancement pour chaque file 𝑭𝒊 : Cyclique avec un quantum de
temps Qi tel que Qi < Qi+1 (Qi+1 = 2Qi )
 La méthode utilisée pour déplacer un processus vers la file de priorité
supérieure : Un processus qui se bloque pour une E/S sera placé dans la file supérieure
où il sera plus prioritaire
 La méthode utilisée pour déplacer un processus vers la file de priorité inférieure :
Si un processus pris dans la file Fi ne s'est pas terminé à la fin du quantum, sa priorité
est réduite. Il sera placé dans la file Fi+1 (sauf pour Fn où il y restera jusqu’à sa
terminaison)

L’algorithme MLFQ est utilisé dans plusieurs systèmes comme Unix, Windows et Solaris.
C’est un des algorithmes les plus intéressants en se basant sur le principe «Apprendre
du passé pour prédire le futur» : Au lieu d’exiger une connaissance préalable sur le
processus -comme dans le cas de SJF et SRTF-, la décision de l’ordonnancement des
processus est faite selon l’évolution de leurs caractéristiques dans le système. Ceci va
offrir de bonnes performances aux processus courts interactifs puisque tout blocage
pour une E/S va être suivi d’une augmentation dans la priorité. D’autres part, les
processus dont le besoin en temps CPU est élevé ne seront pas pénalisés. Néanmoins, ces
derniers peuvent souffrir du problème de « famine » en présence d’un grand nombre de
processus courts interactifs.

6 Cas Pratiques : Unix et Windows

Les systèmes Unix et Windows utilisent des variantes de l’approche MLFQ.

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem

Chapitre 2 Gestion du Processeur 12

6.1 Ordonnancement dans le système Unix

On prend l’exemple du système Unix 4.3 BSD dont l’ordonnancement est basé sur les
principes suivants :
– Valeurs des priorités: [0 − 127] (avec 0 la priorité maximale), les valeurs [0 − 49]
pour les processus noyau et les valeurs [50 − 127] pour les processus utilisateur
– Les processus de même priorités sont ordonnancés par l’algorithme cyclique
– La priorité de chaque processus prêt en mémoire est recalculée périodiquement
(chaque seconde). Les processus sont alors replacés dans la file qui correspond à la
nouvelle priorité : 𝑃𝑟𝑖𝑜𝑟𝑖𝑡é = 𝑏𝑎𝑠𝑒 + 𝑇⁄2 avec 𝑏𝑎𝑠𝑒 : la priorité de base attribuée
par le S.E. aux processus utilisateur (la même valeur), 𝑇 : Nombre de tops
d’horloges pendant lequel le processus a utilisé le CPU récemment. A chaque
pulsation d’horloge, le compteur de la valeur 𝑇 est incrémenté par 1 pour le
processus en exécution. Chaque seconde, avant de recalculer 𝑃, la valeur 𝑇 est
divisée par 2 afin de ne pas pénaliser les processus ayant utilisé le CPU «pour
longtemps». De cette façon, l’influence du temps CPU utilisé par un processus
diminue à mesure que le processus attend le CPU.
L’objectif est de donner plus de priorités aux processus qui n’on pas beaucoup utilisé le
CPU dans un passé récent. Cette formule donne des priorités supérieures aux processus
ayant utilisé moins de temps CPU dans le passé récent. Par exemple : priorité (éditeur
de texte comme VI) > priorité (processus de calcul) car l’éditeur consomme plus de
temps E/S par rapport au temps CPU.

6.2 Ordonnancement dans le système Windows

On prend l’exemple de Windows NT, 2000, XP. Ce système utilise une approche basée
sur MLFQ avec 32 niveaux de priorités. Les threads (processus) de même priorité sont
dans une même file et ordonnancés par l’algorithme round robin.
– Les processus (thread) Temps réel (opérations critiques) ont des priorités fixes
[16-31].
– Les threads Utilisateur ont des priorités dynamiques [1-15] : Le S.E attribut une
valeur de priorité initiale à un thread. Cette valeur peut être temporairement
augmenté durant la durée de vie du thread. Le changement de la priorité engendre
le changement de la file dans la même classe seulement (même le niveau 15). Si un
thread est interrompu pour une E/S, le noyau Windows augmente sa priorité. Si un
thread est interrompu car il a épuisé son quantum, le noyau diminue sa priorité.
Ainsi, les threads qui consomment plus de temps CPU auront des priorités
inférieures et les threads ayant plus de temps E/S ont tendance à avoir des priorités
plus élevées. Dans le cas des threads dominés par des E/S, le noyau augmente la
priorité plus pour les attentes interactives (attente clavier ou affichage) que pour
d'autres types d'E/S (E/S du disque) (augmenter la réactivité des applications
interactives).

USTO-MB L2 Informatique Notes de Cours Système d’Exploitation I D.Mokeddem