Corrigé de Série TD2

Université Blida 1
Faculté des Sciences

Département d’Informatique
Master SSI (Sécurité des Systèmes d’Informations)
Semestre 2
CORRIGÉ DE LA SÉRIE TD N°2 :

ORDONNANCEMENT DES
PROCESSUS
Mme AROUSSI
2020-2021
Disponible sur https://sites.google.com/a/esi.dz/informatiqueblida/

EXERCICE 1
En utilisant le tableau suivant qui présente la priorité, la durée d’exécution et
l’instant d’arrivé création de chaque processus:
Processus P1 P2 P3 P4 P5 P6 P7 P8 P9
Priorité 5 10 0 20 20 25 10 10 5
Durée d’exécution 7 20 12 10 20 10 18 36 15
Instant d’arrivé 22 24 0 0 28 4 30 4 10
1. Dans le cas des files d’attente multi-niveaux avec priorité,

1.1. Donner le schéma du système d’ordonnancement.
1.2. Donner la séquence d’ordonnancement dans le cas où la politique
d’ordonnancement de chaque file est (a) FCFS, (b) SJF ou (c) RR (quantum = 8).
1.3. Calculer le temps de réponse, le temps d’attente et le temps de résidence
2
pour chaque cas.
EXERCICE 1
Question 1: Algorithme d’ordonnancement des files d’attente multi-
niveaux avec priorité
1.1. Schéma du système d’ordonnancement
Queue Tête
max 31
25 ……… P6
20 ……… P5 P4
10 ……… P7 P2 P8
5 ……… P1 P9
3
min 0 ……… P3
Priorité
Processus 1.2.a. Algorithme d’ordonnancement des files d’attente multi-niveaux
(priorité; durée) avec priorité où la politique d’ordonnancement de chaque file est FCFS
F5 = [,,,,,P1, P9]
P1 22
(5; 7)
CPU 136 √
24
P2 CPU 96 √
(10; 20)
P3 CPU 148 √
(0; 12)
P4 CPU 20 √
(20; 10)
28
P5 CPU 48 √
(20; 20)
P6 4
CPU 14 √ F10 = [,,,,,P7, P2, P8]
(25; 10)
30
P7 CPU 114 √
(10; 18)
4
P8 CPU 28 CPU 76 √
(10; 36)
10 4
P9 CPU 129 √
(5; 15)
Temps
EXERCICE 1
1.2.a. La politique d’ordonnancement de chaque file est FCFS
Processus Séquence d’ordonnancement
P1 Début 22 AttCPU 129 CPU 136 Fin
P4 Début 0 CPU 4 AttCPU 14 CPU 20 Fin
P5 Début 28 CPU 48 Fin
P6 Début 4 CPU 14 Fin
P8 Début 4 AttCPU 20 CPU 28 AttCPU 48 CPU 76 Fin
Ordre d’exécution des processus:
5
P4 P6 P4 P8 P5 P8 P2 P7 P9 P1 P3 Processus
| | | | | | | | | | | |
0 4 14 20 28 48 76 96 114 129 136 148 Instants
EXERCICE 1
1.3. La politique d’ordonnancement de chaque file est FCFS
Temps de réponse (Trep) = Instant_Début_Exécution – Instant_Arrivé
Temps d’attente (Tatt) = Temps_AttCPU + Temps_AttES.
Temps de résidence (Tres)= Instant_Fin_Exécution – Instant_Arrivé
Vu qu’il n’y a pas des E/S dans les exécutions des processus (Temps_ATTES = 0) donc
Temps d’attente peut être déduit comme suit: = Tres – Tex (Tex: durée d’exécution). Cela
est utile pour vérifier vos calculs.
6
EXERCICE 1
1.3. La politique d’ordonnancement de chaque file est FCFS
Séquence d’ordonnancement Trep Tatt Tres

P1 Début 22 AttCPU 129 CPU 136 Fin 129 – 22 = 107 107 136 – 22 = 114
P4 Début 0 CPU 4 AttCPU 14 CPU 20 Fin 0–0=0 14 – 4 = 10 20 – 0 = 20
P5 Début 28 CPU 48 Fin 28 – 28 = 0 0 48 – 28 = 20
P6 Début 4 CPU 14 Fin 4–4=0 0 14 – 4 = 10
P7 Début 30 AttCPU 96 CPU 114 Fin 96 - 30 = 66 66 114 – 30 = 84
P8 D 4 AttCPU 20 CPU 28 AttCPU 48 CPU 76 F 20 – 4 = 16 16 + (48 – 28) = 36 76 – 4 = 72
P9 Début 10 AttCPU 114 CPU 129 Fin 114 – 10 = 104 104 7
129 – 10 = 119
Processus 1.2.b. Algorithme d’ordonnancement des files d’attente multi-niveaux
(priorité; durée) avec priorité où la politique d’ordonnancement de chaque file est SJF
F5 = [,,,,, P9, P1]

P1 22
(5; 7)
CPU 121 √
24
P2 CPU 86 √
(10; 20)
P3 CPU 148 √
(0; 12)
P4 CPU 20 √
(20; 10)
28
P5 CPU 48 √
(20; 20)
P6 4
CPU 14 √ F10 = [,,,,,P8, P2, P7]
(25; 10)
30
P7 CPU 66 √
(10; 18)
4
P8 CPU 28 CPU 114 √
(10; 36)
10 8
P9 CPU 136 √
(5; 15)
Temps
EXERCICE 1
1.La politique d’ordonnancement de chaque file est SJF
Les files d’attentes sont ordonnées selon la durée d’exécution, donc à
*t = 22, F5 = [,,,,, P9, P1] *t = 30, F10 = [,,,,,P8, P2, P7]
P1 Début 22 AttCPU 114 CPU 121 Fin 92 92 99
P4 Début 0 CPU 4 AttCPU 14 CPU 20 Fin 0 10 20
P5 Début 28 CPU 48 Fin 0 0 20
P8 Début 4 AttCPU 20 CPU 28 AttCPU 86 CPU 114 Fin 16 74 110
9
Processus 1.2.c. Algorithme d’ordonnancement des files d’attente multi-niveaux avec
(priorité; durée) priorité où la politique d’ordonnancement de chaque file est RR (q = 8)
P1 22
(5; 7)
24
P2 CPU 56 CPU 80 100 √
(10; 20)
P3 Insérer au début de F20 avec le quantum restant (q = 4)
(0; 12)
P4 CPU 20 √ Fin de quantum, attribuer un nouveau quantum
(20; 10)
28
P5 CPU 48 √
(20; 20)
P6 4
(25; 10)
CPU 12 CPU 14 √ F10 = [,,,,,,,P7,P8,P2]
30
P7 CPU 72 CPU 96
(10; 18)
4
P8 CPU 28 CPU 64 CPU 88
(10; 36)
10 10
P9 Insérer à la fin de F10 avec un nouveau quantum (q = 8)
(5; 15)
Temps
Processus 1.2.c. Algorithme d’ordonnancement des files d’attente multi-niveaux avec
(priorité; durée) priorité où la politique d’ordonnancement de chaque file est RR (q = 8)
P1
(5; 7)
CPU 129 √
P2 CPU 100 √
(10; 20)
P3 CPU 148 √
(0; 12)
P4
(20; 10)
P5
(20; 20)
P6
(25; 10)
P7 CPU 110 √
(10; 18)
P8 CPU 108 CPU 114 √
(10; 36)
11
P9 CPU 122 CPU 136 √
(5; 15)
Temps
EXERCICE 1
1.La politique d’ordonnancement de chaque file est RR
A la fin du quantum, le processus sera inséré à la fin de sa file
A l’arrivé du processus prioritaire, le processus interrompu sera inséré à la tête de la file avec le
quantum restant
P2 Début 24 AttCPU 48 CPU 56 AttCPU 72 CPU 80 AttCPU 96 CPU 100 Fin 20 56 76
P8 Début 4 AttCPU 20 CPU 28 AttCPU 56 CPU 64 AttCPU 80 CPU 88 AttCPU 16 74 12
110
100 CPU 108 AttCPU 110 CPU 114 Fin
EXERCICE 1
En utilisant le tableau suivant qui présente la priorité, la durée d’exécution et
l’instant d’arrivé création de chaque processus:
Processus P1 P2 P3 P4 P5 P6 P7 P8 P9
Priorité 5 10 0 20 20 25 10 10 5
Durée d’exécution 7 20 12 10 20 10 18 36 15
Instant d’arrivé 22 24 0 0 28 4 30 4 10
2. Dans le cas de quatre (4) files d’attente multi-niveaux rétroactives où la

stratégie d’ordonnancement de chaque file est la suivante : F0 (RR avec q = 4),
F1 (RR avec q = 8), F2 (RR avec q = 16) et F3 (SJF)
2.1. Donner la séquence d’ordonnancement des processus
2.2. Calculer le temps de réponse, le temps d’attente et le temps de résidence
13
de chaque processus.
EXERCICE 1
niveaux rétroactives
File d’attente 0 Quantum = 4
priorité
File d’attente 3 SJF
14
EXERCICE 1
30 28 24 22 10 4 4 0 0 Instants
P7 (18) P5 (20) P2 (20) P1(7) P9 (15) P8 (36) P6 (10) P4 (10) P3 (12) F0
F1
F2
F3
15
2. Algorithme d’ordonnancement des files d’attente multi-niveaux
Processus
durée) rétroactives à 4 files : F0 (RR avec q = 4), F1 (RR avec q = 8), F2 (RR avec q
= 16) et F3 (SJF)
22
P1
(7)
24
P2
(20)
P3 CPU 4 AttCPU (F1)
(12)
(10)
28
P5
(20)
P6 4
CPU 12 AttCPU (F1)
(10)
P7 30
(18)
4
P8 AttCPU (F0) CPU 16 AttCPU (F1)
(36)
10 16
(15)
Temps
EXERCICE 1
Question 2: Algorithme d’ordonnancement des files d’attente multi-niveaux
rétroactives
A t = 20, P3 (q = 8 )sera exécuté

Instants
F0
20 16 12 8 4 Instants
P9 (11) P8 (32) P6 (6) P4 (6) P3 (8) F1
Instants
F2
Instants
F3
A t = 22, le processus P1 arrive, et il sera inséré dans F0 (donc plus prioritaire). P3 sera inséré
17
dans F0 à la tête avec quantum restant (q = 6) et il ne sera exécuté qu’à l’instant 38.
Processus
= 16) et F3 (SJF)
22
P1 insérer dans F1 à la tête avec AttCPU (F1)
CPU 26
(7)
quantum restant (q = 6) 24
(20)
P3 AttCPU (F1)
(12)
CPU 4 CPU 22 AttCPU (F1) CPU 44 √
P4 CPU 8 AttCPU (F1) CPU 50 √
(10)
28
(20)
P6 4
CPU 12 √
AttCPU (F1) CPU 56 √
(10)
P7 30
CPU 38 AttCPU (F1)
(18)
4
(36)
10 18
(15)
Temps
Processus
= 16) et F3 (SJF)
P1
(7)
(20)
P3
(12) √
P4
(10)
CPU 56 √
(20)
P6
(10)
√
(18)
(36)
19
(15)
Temps
EXERCICE 1
A t = 99
F0
F1
91 83 75 72 64 Instants
P7 (6) P5 (8) P2 (8) P9 (3) P8 (24) F2
F3
20
Processus
= 16) et F3 (SJF)
P1
(7)
P2 AttCPU (F1) AttCPU (F2)
(20)
CPU 83 CPU 126 √
P3
(12) √
P4
(10)
CPU 56 √
(20)
CPU 91 CPU 134 √
P6
(10)
√
P7 AttCPU (F1) CPU 99 AttCPU (F2) CPU 140 √
(18)
P8 CPU 64 AttCPU (F2) CPU 115 AttCPU (F3)
(36)
21
(15)
Temps
EXERCICE 1
A t = 140
F0
F1
F2
115 Instants
P8 (8) F3
22
Processus
= 16) et F3 (SJF)
P1
(7)
(20)
CPU 83 CPU 126 √
P3
(12) √
P4
(10)
CPU 56 √
(20)
CPU 91 CPU 134 √
P6
(10)
√
P7 AttCPU (F1) CPU 99 AttCPU (F2) CPU 140 √
(18)
P8 CPU 64 AttCPU (F2) CPU 115 AttCPU (F3) CPU 148 √
(36)
23
(15)
Temps
EXERCICE 1
AttCPU dans F0 ; AttCPU dans F1; AttCPU dans F2; AttCPU dans F3.

P3 Début 0 CPU 4 AttCPU 20 CPU 22 AttCPU 44 Fin 0 32 44
P8 Début 4 AttCPU 12 CPU 16 AttCPU 56 CPU 64 AttCPU 99 CPU 115 8 108 144
AttCPU 140 CPU 148 Fin
108
EXERCICE 2
Soient les threads T1, T2, T3 et T4 s’exécutant sur Windows
Thread Priorité Instant Historique d’exécution
d’arrivé
T1 8 0 8 ES(F0) 12 ES(F1) 10 ES(F0) 2
T2 24 6 10 ES(F0) 10 ES(F0) 2
T3 24 20 4 ES(F0) 8 ES(F1) 10 ES(F1) 6
T4 14 22 6 ES(F1) 10 ES(F1) 2
La durée moyenne d'une opération d'E/S est de 10 u.t. On dispose de 2

périphériques (F0 et F1) qui peuvent être partagés par les différents threads.
Sur un périphérique donné, les opérations d'E/S sont effectuées
séquentiellement. 25
EXERCICE 2
Soient les threads T1, T2, T3 et T4 s’exécutant sur Windows
d’arrivé
T1 8 0 8 ES(F0) 12 ES(F1) 10 ES(F0) 2
T2 24 6 10 ES(F0) 10 ES(F0) 2
T3 24 20 4 ES(F0) 8 ES(F1) 10 ES(F1) 6
T4 14 22 6 ES(F1) 10 ES(F1) 2
1. Donner l’ordre d’exécution de ces threads
2. Calculer le temps de résidence et le temps d'attente de chaque thread. En

déduire le taux d'utilisation du processeur. 26
EXERCICE 2
Algorithme d’ordonnancement sur Windows : un algorithme préemptif à
priorité dynamique avec des files d’attente multiniveaux rétroactives.
Threads Priorité Quantum
Temps réel
Fixe entre 16 et 31 Fixe à 20 ms
(T2, T3)
Variable entre 1 et 15:
Variable entre 20 ms et 120 ms :
Utilisateur • +6 à la fin d’E/S sur F0
• +20 à chaque passage à une file
(T1, T4) • +1 à la fin d’E/S sur F1
inférieure
• -1 à la fin du quantum
L’algorithme d’ordonnancement de chaque file est RR.

A la fin d’E/S, le thread est inséré en tête de la file correspondante à sa nouvelle priorité.
27
A la fin du quantum, le thread est inséré en queue de la file correspondante à sa nouvelle
priorité.
EXERCICE 2
d’arrivé
T1 8 0 8 ES(F0) 12 ES(F1) 10 ES(F0) 2
T2 24 6 10 ES(F0) 10 ES(F0) 2
T3 24 20 4 ES(F0) 8 ES(F1) 10 ES(F1) 6
T4 14 22 6 ES(F1) 10 ES(F1) 2
Priorité = 8 + 6 = 14; Prio = 14 + 1 (F1) – 1 (q =0) = 14

Threads Q = 12 Q = 40
(priorité, quantum) Insérer au début de F14 insérer à la fin de F14
T1 CPU 6 AttCPU CPU 18 AttF0 F0 36 CPU 46 AttCPU CPU 56 AttF1 F1 74

(8, 20)
T2 6
CPU 16 F0 26 CPU 36 AttF0 F0 56 CPU 58 √
(24, 20)
T3 20
CPU 24 AttF0 F0 46 CPU 54 F1 64 CPU 74
(24, 20)
T4 22
(14, 20) CPU 26 AttCPU CPU 62 AttF1
28
Temps
EXERCICE 2
d’arrivé
T1 8 0 8 ES(F0) 12 ES(F1) 10 ES(F0) 2
T2 24 6 10 ES(F0) 10 ES(F0) 2
T3 24 20 4 ES(F0) 8 ES(F1) 10 ES(F1) 6
T4 14 22 6 ES(F1) 10 ES(F1) 2
Threads Priorité = Min (14 + 6, 15) = 15; Q = 30; Insérer au début de F15
(priorité, quantum)
T1 F1 74 CPU 84 F0 94 AttCPU CPU 102 √
(14, 40)
T2 Prio = Min (15 +1, 15) = 15; Q = 4; insérer au début de F15

(24, 20)
√
T3 CPU 74 AttF1 F1 94 CPU 100 √

(24, 20)
T4
AttF1 F1 84 CPU 94 F1 104 CPU 106 √ 29
(14, 20)
Temps
Prio = Min (14 +1, 15) = 15; Q = 14; insérer au début de F15
EXERCICE 2
Algorithme d’ordonnancement sur Windows
Séquence d’ordonnancement
T1 Début 0 CPU 6 AttCPU 16 CPU 18 AttF0 26 F0 36 CPU 46 AttCPU 54 CPU 56 AttF1
64 F1 74 CPU 84 F0 94 AttCPU 100 CPU 102 Fin
T2 Début 6 CPU 16 F0 26 CPU 36 AttF0 46 F0 56 CPU 58 Fin
T3 Début 20 CPU 24 AttF0 36 F0 46 CPU 54 F1 64 CPU 74 AttF1 84 F1 94 CPU 100 Fin
T4 Début 22 AttCPU 24 CPU 26 AttCPU 58 CPU 62 AttF1 74 F1 84 CPU 94 F1 104 CPU
106 Fin
Pour le thread 1
Instants 0 36 74 94
Priorité 8 8 + 6 (F0) = 14 + 1 (F1) – 1 (q =0) = 14 Min (14 + 6 (F0),
14 Il sera inséré à la fin de la file de priorité 14 15) = 15
Quantum (ms) 20 12 0 40 30
30
Pour le thread 4: Instants 22 84 104
(Q = 20 ms) Priorité 14 Min (14 +1, 15) = 15 Min (15 + 1, 15) = 15
EXERCICE 2
106 Fin
Ordre d’exécution sur CPU
T1 T2 T1 T3 T4 T2 T1 T3 T1 T2 T4 T3 T1 T4 T3 T1 T4
| | | | | | | | | | | | | | | | | |
| | |
0 6 16 18 20 24 26 36 46 54 56 58 62 74 84
64 94 100 102 104 106
31
CPU inactif
EXERCICE 2
106 Fin
Pour vérifier, Tatt_total= Tres – (Tex + TES)
Thread Tex = Tres Tatt Taux d’utilisation du processeur (TUCPU)
TCPU CPU F0 F1 Total (*)
∑
T1 32 102 24 8 8 40 TUCPU = × 100=
T2 22 52 0 10 0 10
T3 28 80 0 12 10 22 × 100 = × 100 32
=
T4 18 84 34 0 12 46 94%
EXERCICE 3
Soient A, B et C trois threads s’exécutant sur Linux.
Threads A B C
Priorité statique 20 18 10
Politique (1) SCHED_FIFO SCHED_FIFO SCHED_FIFO
d’ordonnancement (2) SCHED_RR SCHED_RR SCHED_RR
(3) SCHED_FIFO SCHED_RR SCHED_OTHER
(4) SCHED_OTHER SCHED_OTHER SCHED_OTHER
Instant d’arrivé 0 0 0
Historique temporelle CPU: 16 ut, E/S: 16 ut; CPU: 25 CPU: 4 ut, E/S: 11 ut; CPU: 30 CPU: 25
Pour chaque politique d’ordonnancement :
1. Donner l’ordre d’exécution de ces threads
2. Calculer le temps de séjour et d’attente pour chaque thread. 33
3. Calculer le nombre de changement de contexte

EXERCICE 3
Soient A, B et C trois threads s’exécutant sur Linux.
Threads A B C
Politique (1) SCHED_FIFO SCHED_FIFO SCHED_FIFO
d’ordonnancement (2) SCHED_RR SCHED_RR SCHED_RR
(3) SCHED_FIFO SCHED_RR SCHED_OTHER
(4) SCHED_OTHER SCHED_OTHER SCHED_OTHER
Instant d’arrivé 0 0 0
On distingue deux cas:
a. les E/S se font sur deux périphériques différents
b. les E/S se font sur le même périphérique (e.g. disque dur) où les requêtes E/S sont traitées
en FCFS, et le périphérique ne traite qu’une seule requête E/S à la fois et lorsqu’une requête
34
est lancée, elle ne peut pas être interrompue.
EXERCICE 3
Algorithme d’ordonnancement sur Linux:
Système d’ordonnancement multiniveaux indépendants
La valeur de priorité varie de 1 à 40 ( 1 plus faible et 40 la plus forte)
Trois politiques d'ordonnancement
Politique Principe Préemptif Priorité Quantum (Q) Critère de
(Prio) sélection
SCHED_FIFO FCFS Oui Statique ///// Priorité
SCHED_RR RR Oui Statique Variable Priorité
Q = Q/2 + prio
SCHED_OTHER RR Oui ////// Variable Note = Q + prio
Q = Q/2 + prio
Priorité entre les classes: un thread de la classe SCHED_FIFO est plus

prioritaire qu’un thread de la classe SCHED_RR qui est plus prioritaire
35
qu’un thread de la classe SCHED_OTHER
EXERCICE 3
Cas (1.a) : Les threads sont de classes SCHED_FIFO et les E/S se font
sur deux périphériques différents
Threads A B C
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
B AttCPU CPU 20 E/S 31 CPU 32 AttCPU CPU 86 √
(18)
C AttCPU AttCPU
(10)
CPU 31 CPU 100 √ 36
Temps
EXERCICE 3
Temps d’exécution = temps CPU
Temps de séjour = temps de résidence
Temps d’attente = temps d’attente CPU + temps d’attente d’E/S
Le contexte du processus est le sous-ensemble de la machine que leur instructions
peuvent modifier ou consulter (registres internes, registres adressables, espace mémoire,
…..). Il permet de reprendre son exécution qui a été interrompu.
Nombre de changement de contexte = nombre de sauvegarde du contexte = nombre de
restauration du contexte
Le sauvegarde de contexte du processus se fait lorsqu’il est interrompu (pour une des
raisons suivantes: arrivée d’un processus plus prioritaire, fin du quantum, demande E/S,
fin anormale ou autre) ou lorsqu’il se termine.
37
La restauration de contexte du processus se fait lorsqu’il est sélectionné par le processeur
pour s’exécuter.
EXERCICE 3
Séquence d’ordonnancement Temps Temps Temps Nombre de
d’exécution de d’attente changement
séjour de contexte
A Début 0 CPU 16 E/S 32 CPU 57 Fin 16+25 =41 57 0 2
B D 0 AttCPU 16 CPU 20 E/S 31 CPU 32 AttCPU 57 CPU 86 F 4+30 = 34 86 41 3
C Debut 0 AttCPU 20 CPU 31 AttCPU 86 CPU 100 Fin 25 100 75 2
Restauration du contexte Sauvegarde du contexte
Threads(priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
38
C AttCPU AttCPU
(10)
CPU 31 CPU 100 √
Temps
EXERCICE 3
Cas (1.b) : Les threads sont de classes SCHED_FIFO et les E/S se font
sur le même périphérique
Threads A B C
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
B AttCPU CPU 20 AttE/S E/S 43 CPU 87 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 39
Temps
EXERCICE 3
Cas (1.b) : Les threads sont de classes SCHED_FIFO et les E/S se font

séjour de contexte
A Début 0 CPU 16 E/S 32 CPU 57 Fin 41 57 0 2
B D 0 AttCPU 16 CPU 20 AttE/S 32 E/S 43 AttCPU 57 CPU 87 F 34 87 42 2
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 40
Temps
EXERCICE 3
Cas (2.a) : Les threads sont de classes SCHED_RR et les E/S se font sur
deux périphériques différents
Threads A B C
Quantum initial 20 18 10
Threads (priorité)
A CPU 16 E/S 32 CPU 36 CPU 56 CPU 57 √
(20)
B
(18)
AttCPU CPU 20 E/S 31 CPU 32 AttCPU CPU 70 CPU 86 √
C AttCPU CPU 30 CPU 31 AttCPU CPU 95 CPU 100 √
(10) 41
Temps
EXERCICE 3
Cas (2.a) : Les threads sont de classes SCHED_RR et les E/S se font sur
deux périphériques différents (même résultats que Cas 1.a)
séjour de contexte
B Début 0 AttCPU 16 CPU 20 E/S 31 CPU 32 AttCPU 57 CPU 86 Fin 34 86 41 3
Threads(priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
42
C AttCPU AttCPU
(10)
CPU 31 CPU 100 √
Temps
EXERCICE 3
Cas (2.b) : Les threads sont de classes SCHED_RR et les E/S se font
Threads A B C
Quantum initial 20 18 10
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 43
Temps
EXERCICE 3
Cas (2.b) : Les threads sont de classes SCHED_RR et les E/S se font
sur le même périphérique (même résultat que Cas 1.b)
séjour de contexte
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 44
Temps
EXERCICE 3
Cas (3.a) : Les threads sont de classes différentes et les E/S se font sur
deux périphériques différents
Threads A B C
Politique SCHED_FIFO SCHED_RR SCHED_OTHER
Quantum initial //////// 18 10
Threads (priorité)
A CPU 16 E/S 32 CPU 57 √
(20)
B AttCPU CPU 20 E/S 31 CPU 32 AttCPU CPU 70 CPU 86 √
(18)
C AttCPU AttCPU
(10)
CPU 30 CPU 31 CPU 95 CPU 100 √
45
Temps
EXERCICE 3
Cas (3.a) : Les threads sont de classes différentes et les E/S se font sur
deux périphériques différents (même résultats que Cas 1.a)
séjour de contexte
B D 0 AttCPU 16 CPU 20 E/S 31 CPU 32 AttCPU 57 CPU 86 F 34 86 41 3
Threads(priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
46
C AttCPU AttCPU
(10)
CPU 31 CPU 100 √
Temps
EXERCICE 3
Cas (3.b) : Les threads sont de classes différentes et les E/S se font sur
le même périphérique
Threads A B C
Politique SCHED_FIFO SCHED_RR SCHED_OTHER
Quantum initial //////// 18 10
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 47
Temps
EXERCICE 3
Cas (3.b) : Les threads sont de classes différentes et les E/S se font sur
le même périphérique (même résultat que Cas 1.b)

séjour de contexte
Threads (priorité)
A E/S 32
(20)
CPU 16 CPU 57 √
(18)
C AttCPU AttCPU
(10)
CPU 32 CPU 100 √ 48
Temps
EXERCICE 3
Cas (4.a) : Les threads sont de classes SCHED_OTHER et les E/S se
font sur deux périphériques différents
Threads A B C
Priorité statique (P) 20 18 10
Quantum (Q) initial (Q = Q/2 + P) 20 18 10
Note (N) initiale (N=P+ Q; Q >0) 20 + 20 = 40 18 + 18 = 36 10 + 10 = 20
Historique temporelle CPU: 16 ut, E/S: 16 ut; CPU: 25 CPU: 4 ut, E/S: CPU: 25
11 ut; CPU: 30
Threads QA= 0; QB= 0; QC = 0 QA= 20; QB= 18; QC = 10 (état initial) QB= 18; QC = 10
(note) NA= 40; NB= 36; NC = 20 NB= 36; NC = 20
A CPU 16 E/S 32 AttCPU CPU 87 CPU 90 √

(40)
B
(36)
AttCPU CPU 20 E/S 31 AttCPU CPU 65 AttCPU CPU 95 √
C
(20)
AttCPU CPU 30 CPU 40 AttCPU CPU 100 √
49
Temps
Réajuster les quanta Q = Q/2 + P QA= 22; QB= 25; QC = 0 QA= 22; QB= 0; QC = 0
QA= 22; QB= 25; QC = 10 NC = 20 NA= 42; NB= 43; NC = 0 NA= 42; NB= 0; NC = 0
EXERCICE 3
Cas (4.a) : Les threads sont de classes SCHED_OTHER et les E/S se
font sur deux périphériques différents

séjour de contexte
A Début 0 CPU 16 E/S 32 AttCPU 65 CPU 90 Fin 41 90 33 2
B D 0 AttCPU 16 CPU 20 E/S 31 AttCPU 40 CPU 65 AttCPU 90 34 95 50 3
CPU 95 Fin
Threads
(note)
A CPU 16 E/S 32 AttCPU CPU 87 CPU 90 √

(40)
B
(36)
AttCPU CPU 20 E/S 31 AttCPU CPU 65 AttCPU CPU 95 √
C AttCPU CPU 100 √
CPU 30 CPU 40 AttCPU
(20)
50
Temps
EXERCICE 3
Cas (4.b) : Les threads sont de classes SCHED_OTHER et les E/S se
font sur le même périphérique
Threads A B C
Priorité statique (P) 20 18 10
Quantum (Q) initial 20 18 10
Note (N) initiale (N=P+ Q) 20 + 20 = 40 18 + 18 = 36 10 + 10 = 20
Threads QA= 0; QB= 25; QC = 0 QB= 18; QC = 10

(note) NA= 0; NB= 43; NC = 0 NB= 36; NC = 20
A CPU 16 E/S 32 CPU 62 CPU 90 √

(40)
B
(36)
AttCPU CPU 20 AttE/S E/S 43 CPU 87 CPU 95 √
C AttCPU CPU 30 CPU 40 AttCPU CPU 100 √

(20)
51
Temps
Réajuster les quanta Q = Q/2 + P QA= 22; QC = 0 QA= 0; QB= 0; QC = 0 QA= 20; QB= 18; QC = 10
QA= 22; QB= 25; QC = 10 NC = 20 NA= 42; NC = 0 (état initial) NA= 40; NB= 36; NC = 20
EXERCICE 3
Cas (4.b) : Les threads sont de classes SCHED_OTHER et les E/S se
font sur le même périphérique

séjour de contexte
A D 0 CPU 16 E/S 32 AttCPU 43 CPU 62 AttCPU 87 CPU 90 F 41 90 33 3
B D 0 AttCPU 16 CPU 20 AttE/S 32 E/S 43 AttCPU 62 CPU 87 34 95 50 3
AttCPU 90 CPU 95 Fin
Threads
(note)
A CPU 16 E/S 32 CPU 62 CPU 90 √

(40)
B
(36)
AttCPU CPU 20 AttE/S E/S 43 CPU 87 CPU 95 √
C AttCPU CPU 30 CPU 40 AttCPU CPU 100 √ 52
(20)
Temps
EXERCICE 4
Rappel sur le Système d’ordonnancement POSIX
La norme POSIX effectue l’ordonnancement à l’aide d’un algorithme

préemptif (réquisition) à priorités fixes.
A tout instant, un thread moins prioritaire peut être interrompu par un

autre thread plus prioritaire que lui.
Queue Tête
max 31
……………………….
……………………….
min 0
53
Priorité
EXERCICE 4
Les threads de même priorité peuvent être traitées selon deux politiques:
SCHED_FIFO : Cela signifie que le thread est prévu jusqu'à ce qu’il se
termine, est annulé par un autre thread, s’est bloqué à la demande d’E/S
par exemple ou est interrompu par un thread plus prioritaire.
SCHED_RR: Le thread est également prévu jusqu’à ce que son quantum
d’ordonnancement expire. Il sera inséré à la queue de sa file.
La norme POSIX propose une troisième politique, appelée SCHED_OTHER
qui dépend de l'implémentation de l’ordonnanceur du S.E. Ceci permet
l’absence de situation de famine (les threads de basse priorité attendent
indéfiniment) qui peut être engendrée avec la politique SCHED_FIFO ou
SCHED_RR. 54
EXERCICE 4
Un thread peut être ordonnancé à la portée du
Système (PTHREAD_SCOPE_SYSTEM). Le thread est sélectionné

parmi l’ensemble des threads du système (des différents processus).
55
EXERCICE 4
Un thread peut être ordonnancé à la portée du
Processus (PTHREAD_SCOPE_PROCESS). Le thread est sélectionné

parmi l’ensemble des threads du même processus (programme).
Les Pthreads d'un même processus sont prises en charge par un pool
de threads noyau.
56
EXERCICE 4
Soient TA1, TA2, TA3, TB1, TB2, TB3, TB4, TC1 et TC2 neuf threads des
différents processus A, B et C qui existent dans le système à un instant t:
Processus Threads Ordre de Priorité Politique Durée

création d’Exécution
A TA1 1 10 SCHED_FIFO 5
TA2 2 20 SCHED_FIFO 3
TA3 3 30 SCHED_FIFO 8
B TB1 1 20 SCHED_RR 3
(quantum = 2)
TB2 2 10 SCHED_RR 6
(quantum = 2)
TB3 3 10 SCHED_RR 5
(quantum = 2)
TB4 4 20 SCHED_RR 8
(quantum = 2)
C TC1 1 30 SCHED_OTHER 8 57
TC2 2 10 SCHED_OTHER 4
EXERCICE 4
1. Dans le cas où l’ordonnancement est à la portée du système
(PTHREAD_SCOPE_SYSTEM),
a. Dessiner le système d’ordonnancement et donner l’ordre d’exécution des
threads à partir de l’instant t sachant que
L’algorithme de l’ordonnancement du système est l’algorithme à
priorité.
L’ordre de création des threads de même priorité est comme suit :
<TA3, TC1>, <TB1, TA2, TB4>, < TB3, TC2, TB2, TA1 >.
b. Que se passe-t-il si la priorité du thread TB4 est modifiée après 3 unités
de son exécution ?
c. Que se passe-t-il si le thread TA2 (ou TA3) appelle la fonction sched_yield
() après 2 unités de son exécution ? 58
EXERCICE 4
Processus A
30 TA3 (FIFO) 1. Question 1 : Ordonnancement à la portée du système
20 TA2 (FIFO)
a. Le système d’ordonnancement
10 TA1 (FIFO)
31’
30’ TC1’ (OTHER) TA3’ (FIFO)
Processus B Thread sélectionné

20’ TB4’ (RR) TA2’ (FIFO) TB1’ (RR)
20 TB4 (RR) TB1 (RR)

10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR)
Ordonnancement
10 TB3 (RR) TB2 (RR)
0’ à priorité
Système d’Ordonnancement du noyau
Processus C
NB:
T’: Threads noyaux
30 TC1 (OTHER)
Les priorités des threads noyaux peuvent être recalulées 59
10 TC2 (OTHER)
SCHED_OTHER ≡ Ordonnancement à priorité
Thread EXERCICE 4
(durée d’exécution)
1. Question 1 : Ordonnancement à la portée du système
TA3 CPU +8 √ a. L’ordre d’exécution des threads
(8)
TC1 CPU +16 √

(8)
TB1 CPU +18 CPU +24 √
(3)
TA2 CPU +21 √
(3)
TB4 CPU +23 CPU +26 CPU +28 CPU +30 √
(8)
TB3 CPU +32
(5) 30’ TC1’ (OTHER) TA3’ (FIFO)
TC2 CPU +36 √
(4)
TB2 CPU +38
(6)
10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR) 60
TA1
(5)
t Temps
Thread EXERCICE 4
(durée d’exécution)
30’ TC1’ (OTHER) TA3 (FIFO)

TA3
(8) √
TC1
(8)
√
10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR)
TB1
(3) √
TA2 √
(3)
TB4
(8)
√
TB3 CPU +32 CPU +45 CPU +48 √
(5)
TC2 CPU +36 √

(4)
TB2 CPU +38 CPU +47 CPU +50 √
(6)
61
TA1 CPU +43 √
(5)
t Temps
EXERCICE 4
a. L’ordre d’exécution des threads
TA3 TC1 TB1 TA2 TB4 TB1 TB4 TB3 TC2 TB2 TA1 TB3 TB2 TB3 TB2 Thread
| | | | | | | | | | | | | | | |
t+ 08 16 18 21 23 24 30 32 36 38 43 45 47 48 50Instant

de son exécution ?
Changement A l’instant t + 25
de priorité 30’
20’ TB4’ (RR)

TB4 +21 CPU +23 +24 CPU +25 62
(8)
Temps 10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR)
EXERCICE 4
de son exécution ?
On distingue deux cas:
Si la nouvelle priorité est supérieure à 10, TB4 continue son exécution
normalement jusqu’à t+30
Sinon (la nouvelle priorité est inférieure ou égale à 10), TB4 sera
interrompu au profit de TB3 et ne sera exécuté que s’il devient le plus
prioritaire A l’instant t + 25
30’
Changement de
priorité
20’ TB4’ (RR)
63
TB4 +21 CPU +23 +24 CPU +25 10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR)
(8)
Temps
EXERCICE 4
c. Que se passe-t-il si le thread TA3 appelle la fonction sched_yield () après
2 unités de son exécution ?
Il sera interrompu au profit de TC1
Il sera inséré à la queue de la file F30
Il ne reprendra l’exécution à la fin d’exécution de TC1 (t+2+8 = t+ 10)
Il se termine à l’instant t+10+6 = t+ 16.
A l’instant t + 2
30’ TC1’ (OTHER)
TA3
(8) CPU +2 CPU +16 √ 20’ TB4’ (RR) TA2’ (FIFO) TB1’ (RR)
TC1 64
CPU +10 √ Temps
(8) 10’ TA1’ (FIFO) TB2’ (RR) TC2’ (OTHER) TB3’ (RR)
t
EXERCICE 4
c. Que se passe-t-il si le thread TA2 appelle la fonction sched_yield () après
2 unités de son exécution ?
Il sera interrompu au profit de TB4
Il sera inséré à la queue de la file F20
Il ne reprendra l’exécution à la fin du quantum de TB4 (t+20+2 = t+ 22)
A l’instant t + 20
Il se termine à l’instant t+22+1 = t+ 23. 30’
20’ TB4’ (RR)
10’ TA1’ TB2’ TC2’ TB3’

TA2 CPU +20 CPU +23 √
(FIFO) (RR) (OTHER) (RR)
(3)
65
TB4
(8) CPU +22 CPU +26 CPU +28 Temps
CPU +30 √
t+18
EXERCICE 4
2. Dans le cas où l’ordonnancement est à la portée du processus
(PTHREAD_SCOPE_PROCESS),
a. Dessiner le système d’ordonnancement et donner l’ordre d’exécution des
threads à partir de l’instant t, sachant que :
L’algorithme de l’ordonnancement du système est l’algorithme
tourniquet classique (quantum = 4).
L’ordre d’arrivé des processus : A, B ensuite C.
Chaque processus est pris en charge par un seul thread noyau
b. Que se passe-t-il si le processus A (B ou C) est pris en charge par deux
threads noyau ?
66
EXERCICE 4
Processus A (FIFO)
30 TA3 1. Question 2 : Ordonnancement à la portée du processus
20 TA2
a. Le système d’ordonnancement
10 TA1
Processus B (RR, q = 2)
20 TB4 TB1
10 TB3 TB2 Thread sélectionné

TC (12) TB (22) TA (16)
Système d’Ordonnancement du noyau (une seule file)

Processus C (OTHER)
Ordonnancement
Une seule file
RR (q = 4)
……….. TC2 TC1
67
SCHED_OTHER ≡ Ordonnancement RR (q = 4)
EXERCICE 4
2. Question 2 : Ordonnancement à la portée du processus
Processus A (FIFO) Processus C (RR, q = 4)
30 TA3 (8) Une seule file
20 TB4 (8) TB1 (3)
Processus 20 TA2 (3) ……….. TC2 TC1
10 TB3 (5) TB2 (6)
(durée d’exécution) 10 TA1 (5)
TA3 TA3 √ TA2 √ TA1

TA CPU +4 CPU +16 CPU +27 CPU +28
(16)
TB1 TB4 TB1 √ TB4 TB4

TB CPU +6 CPU +8 CPU +17 CPU +19 CPU +20
(22)
TC1 TC2 √
TC CPU +12 CPU +24 68
(12)
t Temps
EXERCICE 4
1. Question 1 : Ordonnancement à la portée du processus
Processus A (FIFO) Processus C (RR, q = 4)
30 Une seule file
20 TB4 (3)
Processus 20 ……….. TC1
10 TB3 (5) TB2 (6)
(durée d’exécution) 10 TA1 (4)
TA1 TA1 √
TA CPU +28 CPU +40 √
(16)
TB4 √ TB2 TB2 TB3 TB2 TB2 TB3 TB2 TB2√ TB3 √
TB CPU +31 CPU +32 CPU +41 CPU +43 CPU +44 CPU +45 CPU +47 CPU +48 CPU +49 CPU +50 √
(22)
TC1 √
TC CPU +36 √ 69
(12)
t Temps
EXERCICE 4
TB2 TB2
TB4 TB4 TA1 TB2 TB3 TB3 TB3
TA3 TB1 TC1 TA3 TB1 TC2 TA2 TB4 TC1 TA1 TB2 TB2 TB2 Threa
| | | | | | | | | | | | | |
t+ 04 08 12 16 20 24 28 32 36 40 44 48 50Instan
70
EXERCICE 4
threads noyau ?
Plusieurs schémas possibles:
exemple 1: TCC TBB TAA TC TB TA
L’ordre d’exécution des threads reste le même que la question 2.a
TB2 TB2
TA3 TB1 TC1 TA3 TB1 TC2 TA2 TB4 TC1 TA1 TB2 TB2 TB2 Threa
| | | | | | | | | | | | | |
t+ 04 08 12 16 20 24 28 32 36 40 44 48 71 50Instan
TA TAA TA TAA
TC TCC TC
TB TBB TB TBB TB TBB
EXERCICE 4
threads noyau ?
Plusieurs schémas possibles:
Exemple 2: TCC TC TBB TB TAA TA
TB2 TB2
TA3 TA3 TB1 TB1 TC1 TC2 TA2 TA1 TB4 TB2 TC1 TB2 TB2 Threa
| | | | | | | | | | | | | |
t+ 04 08 12 16 20 24 28 32 36 40 44 48 72 50Instan
TA TAA TA TAA
TB TBB TB TBB TB TBB
TC TCC TC

Corrigé de Série TD2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Corrigé de Série TD2

Transféré par

Droits d'auteur :

Formats disponibles

Université Blida 1

Faculté des Sciences

CORRIGÉ DE LA SÉRIE TD N°2 :

Disponible sur https://sites.google.com/a/esi.dz/informatiqueblida/

1. Dans le cas des files d’attente multi-niveaux avec priorité,

Temps d’attente (Tatt) = Temps_AttCPU + Temps_AttES.

Temps de résidence (Tres)= Instant_Fin_Exécution – Instant_Arrivé

Séquence d’ordonnancement Trep Tatt Tres

F5 = [,,,,, P9, P1]

2. Dans le cas de quatre (4) files d’attente multi-niveaux rétroactives où la

File d’attente 0 Quantum = 4

File d’attente 2 Quantum = 16

File d’attente 3 SJF

A t = 20, P3 (q = 8 )sera exécuté

Séquence d’ordonnancement Trep Tatt Tres

La durée moyenne d'une opération d'E/S est de 10 u.t. On dispose de 2

1. Donner l’ordre d’exécution de ces threads

2. Calculer le temps de résidence et le temps d'attente de chaque thread. En

L’algorithme d’ordonnancement de chaque file est RR.

Priorité = 8 + 6 = 14; Prio = 14 + 1 (F1) – 1 (q =0) = 14

T1 CPU 6 AttCPU CPU 18 AttF0 F0 36 CPU 46 AttCPU CPU 56 AttF1 F1 74

T2 Prio = Min (15 +1, 15) = 15; Q = 4; insérer au début de F15

T3 CPU 74 AttF1 F1 94 CPU 100 √

Pour chaque politique d’ordonnancement :

1. Donner l’ordre d’exécution de ces threads

2. Calculer le temps de séjour et d’attente pour chaque thread. 33

3. Calculer le nombre de changement de contexte

Priorité entre les classes: un thread de la classe SCHED_FIFO est plus

Restauration du contexte Sauvegarde du contexte

Séquence d’ordonnancement Temps Temps Temps Nombre de

Séquence d’ordonnancement Temps Temps Temps Nombre de

A CPU 16 E/S 32 AttCPU CPU 87 CPU 90 √

Séquence d’ordonnancement Temps Temps Temps Nombre de

A CPU 16 E/S 32 AttCPU CPU 87 CPU 90 √

Threads QA= 0; QB= 25; QC = 0 QB= 18; QC = 10

A CPU 16 E/S 32 CPU 62 CPU 90 √

C AttCPU CPU 30 CPU 40 AttCPU CPU 100 √

Séquence d’ordonnancement Temps Temps Temps Nombre de

A CPU 16 E/S 32 CPU 62 CPU 90 √

La norme POSIX effectue l’ordonnancement à l’aide d’un algorithme

A tout instant, un thread moins prioritaire peut être interrompu par un

Un thread peut être ordonnancé à la portée du

Système (PTHREAD_SCOPE_SYSTEM). Le thread est sélectionné

Un thread peut être ordonnancé à la portée du

Processus (PTHREAD_SCOPE_PROCESS). Le thread est sélectionné

Processus Threads Ordre de Priorité Politique Durée

Processus B Thread sélectionné

20 TB4 (RR) TB1 (RR)

TC1 CPU +16 √

30’ TC1’ (OTHER) TA3 (FIFO)

TC2 CPU +36 √

b. Que se passe-t-il si la priorité du thread TB4 est modifiée après 3 unités

20’ TB4’ (RR)

20’ TB4’ (RR)

10’ TA1’ TB2’ TC2’ TB3’

10 TB3 TB2 Thread sélectionné

Système d’Ordonnancement du noyau (une seule file)

TA3 TA3 √ TA2 √ TA1

TB1 TB4 TB1 √ TB4 TB4

Système d’Ordonnancement du noyau (une seule file)

L’ordre d’exécution des threads reste le même que la question 2.a

Système d’Ordonnancement du noyau (une seule file)

Vous aimerez peut-être aussi