Ecole Nationale Polytechnique d’Oran- Maurice AUDIN

Département de Génie des Systèmes Informatiques

Intitulé de la matière: Programmation Système

Gestion des processus

ème
(2 partie)
Dr. Nawel BENDIMERAD

Année universitaire 2023/2024

1
 9/ Ordonnancement des processus
• Dans un système multitâches, plusieurs processus peuvent être
prêts simultanément.
• Le système d’exploitation doit gérer l’exécution des processus
dans les meilleurs délais possibles en partageant le temps
processeur.
• Le programme du système d’exploitation qui se charge de
l’allocation du processeur aux différents processus est appelé
l’ordonnanceur (Scheduler).
• L’ordonnancement (Scheduling) définit l’ordre d’exécution des
processus (les processus dans l’état ready sont examinés) et la
stratégie utilisée dans ce cadre s’appelle l’algorithme
d’ordonnancement.
2
 Catégories d’ordonnanceurs
Il existe trois catégories d’ordonnanceurs : à long terme, à court terme
et à moyen terme.
• Ordonnanceur à long terme :
▪L’ordonnanceur fait la sélection de processus à admettre dans la
file des processus prêts.
▪S’exécute moins fréquemment.
▪L’admission dépend de la capacité du système (degré de
multiprogrammation (le nombre de processus dans la mémoire)).
• Ordonnanceur à court terme :
▪L’ordonnanceur à court terme a comme tâche la gestion de la file
des processus prêts.
▪Il sélectionne (en fonction d'une certaine politique) le prochain
processus à exécuter.
▪Il est appelé assez fréquemment: doit être très rapide 3
 Catégories d’ordonnanceurs

• Ordonnanceur à moyen terme :

▪Idée : Il peut être avantageux de supprimer des processus de
la mémoire et réduire ainsi le degré de multiprogrammation.
▪Plus tard, un processus peut être réintroduit dans la mémoire
et son exécution peut reprendre là ou elle s’était arrêtée.
▪Ce schéma est appelé swapping (transfert des informations
de la mémoire principale à la mémoire auxiliaire et
vice-versa).

4
 Objectifs de l’ordonnancement
• Le rôle majeur de l’ordonnancement est de maximiser
l’utilisation des ressources (identifier le processus qui conduira
à la meilleure performance possible du système).
• Un bon algorithme d’ordonnancement doit être capable de :
1. s’assurer que chaque processus reçoit sa part du temps
processeur (respecter l’équité entre les processus selon le
critère d’ordonnancement utilisé),
2. utiliser le temps processeur à 100% (au maximum),
3. minimiser le temps de réponse des processus,
4. maximiser le nombre de travaux effectués dans un intervalle
de temps.

5
 Critères d’ordonnancement
• Les critères d’ordonnancement fréquemment utilisés sont les
suivants:
▪ Utilisation du processeur : Pourcentage de temps pendant lequel le
processeur exécute un processus. L’importance de ce critère varie
généralement en fonction du degré de partage du système.
▪ Débit : Nombre de processus pouvant être exécutés par le système
sur une période de temps donnée.
▪ Temps de rotation : le temps réel qu’il faut à un processus pour
s’exécuter. Le temps de rotation d’un processus comprend tout le
temps que celui-ci passe dans le système (la somme des périodes
d’attente dans les files, d’E/S et d’exécution). Il est inversement
proportionnel au débit.
Temps de rotation=Temps fin d’exécution - Temps d’arrivée
6
 Critères d’ordonnancement
▪ Temps d’attente : quantité de temps qu’un processus passe à
attendre dans les différentes files .
Temps d’attente=Temps de rotation – Durée d’exécution
▪ Temps de réponse : le temps qui s’écoule entre la soumission d’une
requête et la première réponse.
▪ Equité : attribuer un temps processeur équitable à chaque processus.
▪ Priorité : attribuer un traitement préférentiel aux processus dont le
niveau de priorité est supérieur.

7
 Types d’ordonnancement
Il existe 2 types d’ordonnancement:
a. Ordonnancement non-préemptif (sans réquisition)
• Le SE sélectionne un processus et le laisse s’exécuter jusqu’à ce
qu’il se bloque ou qu’il libère volontairement le processeur.
b. Ordonnancement préemptif (avec réquisition)
• Le SE sélectionne un processus et le laisse s’exécuter pendant un
délai maximum déterminé : le quantum (avant de passer la main
à un autre processus).
• Pour s’assurer qu’aucun processus ne s’exécute pendant trop
longtemps, les ordinateurs ont une horloge électronique qui
génère périodiquement une interruption.
• A chaque interruption d’horloge, le SE reprend la main et décide
si le processus courant doit poursuivre son exécution ou s’il doit
être suspendu pour laisser place à un autre.
8
 Décisions d’ordonnancement
• Les décisions d’ordonnancement peuvent avoir lieu par exemple
dans l’une des trois circonstances suivantes :
1. Un processus commute de l’état en exécution vers l’état en attente
(requête d’E/S).
2. Un processus commute de l’état en exécution vers l’état prêt
(quantum de temps épuisé).
3. Un processus se termine.
• Dans les circonstances 1 et 3, l’ordonnanceur doit choisir un
nouveau processus. Nous parlerons dans ce cas d’ordonnancement
sans réquisition.
• Dans le cas 2, l’ordonnanceur peut choisir d’interrompre le
processus courant pour allouer le processeur à une autre tâche. Nous
parlerons dans ce cas d’ordonnancement avec réquisition.
9
 Algorithmes d’ordonnancement (1)
Ordonnancement FCFS
(First Come First Served, Premier Arrivé, Premier Servi)
• Le plus simple algorithme d’ordonnancement.
• Ordonnancement non préemptif (sans réquisition).
• Le premier processus qui demande le processeur le reçoit en premier.
• Il peut être mis en œuvre simplement grâce à une file d’attente FIFO.
• Quand un processus rentre dans la file d’attente des processus prêts, son
BCP est enchainé en queue de file.
• Dès que le processeur est libre, il est alloué au processus en tête de file.
• Le processus en cours d’exécution est alors retiré de la file.
• Avantage : algorithme simple (prendre le premier processus non bloqué de
la file).
• Inconvénient : les processus longs monopolisent le processeur donc le
temps d’attente moyen est souvent long.

10
 Ordonnancement FCFS
Exemple

• Soient quatre processus P1, P2, P3 et P4 dont le temps d’arrivée et la

durée d’exécution sont donnés dans le tableau suivant:

Processus Temps d’arrivée Durée d’exécution

P1 0 7

P2 1 5

P3 2 2

P4 3 5

• Dessiner le diagramme de Gantt illustrant l’exécution de ces

processus.
• Calculer le temps de rotation moyen et le temps d’attente moyen. 11
 Ordonnancement FCFS
Exemple

• Le diagramme de Gantt permet de représenter l’historique

d’occupation du processeur, il est représenté de la manière suivante :

• Le temps de rotation moyen et le temps d’attente moyen sont calculés

de la manière suivante :
Temps de rotation=Temps fin d’exécution - Temps d’arrivée
Temps de rotation moyen= ( (7) + (12-1) + (14-2) + (19-3) )/4 =46/4 =
11,5
Temps d’attente=Temps de rotation – Durée d’exécution
Temps d’attente moyen= ( (0) + (11-5) + (12-2) + (16-5) )/4 =27/4 =
12
6,75
 Algorithmes d’ordonnancement (2)
SJF (Shortest Job First, Plus Court Temps
d'Exécution en Premier)
• L’algorithme SJF est non préemptif
• Sélection du processus nécessitant le moins de temps d’exécution.
• Si deux processus ont la même longueur de cycle alors l’algorithme
FCFS est utilisé.
• Avantages:
▪ Favorise les petits jobs.
▪ Il obtient le temps d’attente moyen minimal pour un ensemble de
processus donné.
• Inconvénient:
▪ Demande de connaître apriori le délai (maximum) d’exécution d’un
processus.

13
 Ordonnancement SJF
Exemple
• On reprend les mêmes données d’ordonnancement illustrées dans
l’exemple précédent. Le diagramme de Gantt correspondant est le
suivant :

• Le temps de rotation moyen et le temps d’attente moyen en utilisant

l’algorithme SJF sont calculés comme suit :
Temps de rotation moyen= ( (7) + (14-1) + (9-2) + (19-3) )/4 =43/4 =
10,75
Temps d’attente moyen= ( (0) + (13-5) + (7-2) + (16-5) )/4 =24/4 = 6

14
 Algorithmes d’ordonnancement (3)
SRTF (Shortest Remaining Time First, Plus Court
Temps d'Exécution Restant en Premier)

• Est la version préemptive de l’algorithme SJF.

• Lorsqu’un processus arrive dans la file des processus,
l’ordonnanceur compare le temps estimé de son exécution
avec celui du processus actuellement en exécution.
• Si le temps d’exécution du nouveau processus est plus petit,
celui-ci rentre en exécution immédiatement.

15
 Ordonnancement SRTF
Exemple
• On reprend les mêmes données d’ordonnancement illustrées dans
l’exemple précédent. Le diagramme de Gantt correspondant est le
suivant :

• Le temps de rotation moyen et le temps d’attente moyen en utilisant

l’algorithme SRTF sont calculés comme suit :
Temps de rotation moyen= ( (19) + (8-1) + (4-2) +(13-3) )/4 =38/4=
9,5
Temps d’attente moyen= ( (19-7) + (7-5)+(2-2)+(10-5) )/4 =19/4= 4,75

16
 Algorithmes d’ordonnancement (4)
Ordonnancement du tourniquet, circulaire ou
RR (Round Robin)
• Algorithme simple et très utilisé, conçu spécialement pour les
systèmes à temps partagé.
• Similaire à FCFS mais avec réquisition du processeur afin de
passer d’un processus à un autre.
• Il mémorise dans une file de type FIFO (First In First Out) la
liste des processus prêts, c’est-à-dire en attente d’exécution.
• On définit une petite tranche de temps appelée quantum.
Chaque processus est donc autorisé à s’exécuter pendant son
quantum de temps.

17
 Implémentation de l’algorithme RR
• La file des processus prêts est une FIFO circulaire.
• Les nouveaux processus sont ajoutés à la fin de la file.
• L’Ordonnanceur RR prend le premier processus dans la file,
initialise un timer pour générer une interruption après un quantum
de temps et lance le processus.
• Premier cas :
▪ Le processus a un cycle CPU inférieure au quantum : il va libérer
lui-même le processeur et RR passe au processus suivant dans la
file des processus prêt.
• Deuxième cas :
▪ Le cycle CPU du processus est plus long que le quantum: le
timer va générer une interruption; en traitant cette interruption, le
SE va mette le processus en fin de la file et RR sélectionne le
prochain processus. 18
 Avantages et inconvénients du RR
• Avantages : garantit que tout processus soit servi au bout d’un
temps Fini (éviter la famine).
• Inconvénients : L’efficacité de cet ordonnanceur dépend
principalement de la valeur du quantum:
▪ Le choix d’un quantum assez petit augmente le nombre de
commutation.
▪ Le choix d’un quantum assez grand augmente le temps de
réponse du système.

Remarque: Le quantum de temps doit être plus grand que le

temps nécessaire à une commutation de contexte mais pas trop
grand pour ne pas devenir un FCFS.

19
 Ordonnancement avec RR
Exemple

• Soient cinq processus P1, P2, P3, P4 et P5 dont le temps d’arrivée et

la durée d’exécution sont donnés dans le tableau suivant:
Processus Temps d’arrivée Durée d’exécution
P1 0 3
P2 1 6
P3 4 4
P4 6 2
P5 7 1

• Dessiner le diagramme de Gantt illustrant l’exécution de ces

processus en utilisant un quantum =1.
• Calculer le temps de rotation moyen et le temps d’attente moyen.
20
 Ordonnancement RR
Exemple
• Le diagramme de Gantt illustrant l’exécution des processus en
utilisant l’algorithme d’ordonnancement RR est le suivant:

• Le temps de rotation moyen et le temps d’attente moyen en utilisant

l’algorithme RR sont calculés comme suit :
Temps de rotation moyen= ( (5) + (16-1) + (15-4) + (12-6) + (10-7) )/5
=40/5 = 8
Temps d’attente moyen= ( (5-3) + (15-6) + (11-4) + (6-2) ) + (3-1))/5
=24/5 = 4,8
21
 Algorithmes d’ordonnancement (5)
Ordonnancement avec priorité
• L’ordonnancement avec priorité peut être préemptif ou non
préemptif.
• Une priorité est associée à chaque processus
• Le processeur est alloué au processus ayant la plus haute
priorité.
• Les processus ayant une même priorité sont ordonnancés selon
le FCFS.
• Un algorithme d’ordonnancement avec priorité préemptif
interrompt le processus courant :
▪ si un processus arrive dans la file des processus prêt
▪ Et si le nouveau processus a une priorité plus élevée que celle
du processus en cours.

22
 Avantages et inconvénients de
l’ordonnancement avec priorité
• Avantage: Permet de classer les processus en fonction de leur
importance pour le système.
• Inconvénients: Un algorithme d’ordonnancement avec priorité
pose un problème majeur :
▪ Blocage infini ou famine (peut laisser des processus à
priorité basse en attente indéfinie).
• Solution :
▪ Incrémenter graduellement la priorité des processus qui
attendent dans le système depuis une longue période
(technique dite du vieillissement (aging)).

23
 Algorithmes d’ordonnancement (6)
Ordonnancement utilisant des files
multi-niveaux
• La file des processus prêts est subdivisée en plusieurs files
d’attente séparées suivant la classe des processus (par exemple,
batch, interactif, temps réel, etc.).
• Ces processus ont des exigences différentes en temps de réponses,
ce qui implique des besoins différents en ordonnancement.
• Cet algorithme est implémenté de la manière suivante :
▪ Une priorité est attribuée à chaque processus.
▪ Les processus de même priorité sont dans une même file.
▪ Il y a autant de files qu’il y a de niveaux de priorité.
▪ Chaque file a son propre algorithme d’ordonnancement.
▪ Un processus peut être servi seulement si toutes les files de
priorité supérieure sont vides. 24
 Ordonnancement utilisant des files
multi-niveaux
Exemple
• Gestion des processus en premier-plan (interactifs) et processus
en arrière-plan (batch processes).
• Algorithme Round Robin pour la file des processus en
premier-plan et FCFS pour les processus en arrière-plan.

25
 Ordonnancement utilisant des files
multi-niveaux
• L’ordonnancement entre les files elles-mêmes peut se faire de
deux manières:
▪ Ordonnancement préemptif avec priorité fixe à chaque file →
famine possible (servir tous les processus en premier-plan
avant les autres), ou
▪ Attribuer à chaque file un certain pourcentage de temps CPU.
Exemple: 80% pour les processus en premier-plan et 20% pour
les processus en arrière-plan.

26
 Algorithmes d’ordonnancement (7)
Ordonnancement avec des files d’attente
feedback à multi-niveaux
• Séparer les processus ayant des caractéristiques différentes de
cycle de CPU en différentes files.
• Permettre aux processus de se déplacer entre les files.
• Processus employant beaucoup de temps processeur: file de
priorité inférieure.
• Processus tributaire d’E/S et intéractifs: file de priorité
supérieure.
• Afin de remédier au problème de famine, un processus qui
attend trop longtemps dans une file de priorité basse peut être
déplacé dans une file de priorité supérieure.
27
 Ordonnancement avec des files d’attente
feedback à multi-niveaux
Exemple
• Soient trois files d’attente avec retour:
File 0 : dont les processus sont gérés suivant l’algorithme Round
Robin avec un quantum de temps de 8 ms.
File 1 : utilise le même algorithme que la File 0 mais avec un
quantum de temps de 16 ms.
File 2 : utilise l’algorithme FCFS pour l’ordonnancement des
processus.

28
 Ordonnancement avec des files d’attente
feedback à multi-niveaux
Exemple
La politique d’ordonnancement est décrite comme suit :
• Lorsqu’un nouveau processus arrive, il est d’abord inséré dans la
File 0, s’il ne termine pas son exécution au bout de 8 ms alors il
sera interrompu et placé dans la File 1.
• Si la File 0 est vide, le processus en tête de la File 1 commence
son exécution. S’il ne termine au bout de 16 ms, il sera alors
interrompu et placé dans la File 2
• Les processus de la File 2 sont exécutés suivant l’algorithme
FCFS uniquement si la File 0 et la File 1 sont vides.

29
 Cas d’étude: Ordonnancement sous Linux
Généralités
• Sous le SE Linux, il existe trois politiques d’ordonnancement :

▪ Deux d’entre elles sont des politiques d’ordonnancement en temps réel. Elles
accordent aux processus une très haute priorité appelées SCHED_FIFO et
SCHED_RR.

▪ La troisième politique d’ordonnancement appelée SCHED_OTHER utilise un

algorithme à temps partagé basé sur des valeurs de priorité.

• Par défaut, un processus est associé à la politique à temps partagé. Seul le mode
superviseur peut associer un processus à une des classes d’ordonnancement en
temps réel.

• Dans tous les cas, chaque processus possède une valeur de priorité comprise entre
-20 et +19. Plus la priorité est basse plus l’ordonnanceur privilégiera ce processus.

• Remarque : Seul le superviseur (root) peut attribuer des valeurs négatives. La

plage de priorité est [-20,19] pour le superviseur et [0,19] pour l’utilisateur. 30
 Ordonnancement sous Linux
FIFO temps réel ou SCHED_FIFO
• Les processus les plus prioritaires sont gérés par cette classe. Si un
processus de la classe FIFO temps réel est à l’état élu, donc il peut
bénéficier d’une utilisation illimitée du processeur.
• Il ne sera interrompu que dans une des circonstances suivantes :
▪ Le processus bloque sur un appel système ou se termine.
▪ Un autre processus de la classe SCHED_FIFO de priorité plus
élevée est prêt. Dans ce cas le processus actuel est remplacé par
celui-ci.
▪ Le processus peut libérer lui-même le processeur, en exécutant
l’appel système sched_yield().
31
 Ordonnancement sous Linux
Round Robin temps réel ou SCHED_RR

• Politique d’ordonnancement préemptive.

• Chaque processus de cette classe se voit attribuer un quantum.
Lorsque ce quantum sera écoulé, le contrôle sera donné à un
autre processus de même priorité de la classe SCHED_RR, s'il
y en a un, en appliquant l’algorithme du Round Robin.
• À noter que le Round Robin ne se fait qu’avec des processus
de même priorité. Un processus temps réel de plus haute
priorité sera toujours privilégié.

32
 Ordonnancement sous Linux
Temps partagé ou SCHED_OTHER
• Cette classe d’ordonnancement est destinée aux processus non prioritaires. Ces processus
s’exécutent uniquement si aucun processus des classes 1 et 2 n’est à l’état prêt.
• Les processus de cette classe se partagent le processeur de manière inégale, selon leur
priorité et leur usage du processeur.
• Chaque processus possède une valeur de priorité qui lui est attribuée au moment de sa
création appelée priorité statique qui peut être modifiée via des appels systèmes.
• Une priorité dynamique est calculée par la suite en prenant en compte la priorité statique
ainsi que d’autres facteurs tels que le taux d’utilisation du processeur et l’intensité des
entrées/sorties.
• En fonction de la valeur de la priorité dynamique, l’ordonnanceur choisi un processus et
lui attribue le processeur pour un temps d’exécution maximal.

33
 Ordonnancement sous Linux
Appels système
Appel Système Description
nice( ) Change la priorité d’un processus.
getpriority( ) Renvoie la priorité maximale d’un groupe de processus.
setpriority( ) Définit la priorité d’un groupe de processus.
sched_getscheduler( ) Renvoie la politique d’ordonnancement d’un processus.
sched_setscheduler( ) Définit la politique d’ordonnancement et la priorité d’un
processus.
sched_getparam( ) Renvoie la priorité d’un processus.
sched_setparam( ) Définit la priorité d’un processus.
sched_yield( ) Abandon volontaire du processeur sans blocage.
sched_get_priority_min( ) Revoie la priorité minimale pour une politique
d’ordonnancement.
sched_get_priority_max( ) Revoie la priorité maximale pour une politique
d’ordonnancement.
sched_rr_get_interval( ) Revoie le quantum de temps pour une politique
d’ordonnancement Round Robin.
34