Module

SYSTEMES D’EXPLOITATION
Exercices

2AP

Année 2023/2024
1
Exercice 1:
Soit un système monoprocesseur ordonnance l’exécution des processus par
un 'algorithme FIFO (First in First Out) (premier arrivé Premier Servi) du
tableur suivant:
Processus Temps de séjour Date d’arrivée
P1 3 0
P2 2 2
P3 4 3
P4 7 5

1) Tracer un diagramme illustrant l’exécution des processus

2) Calculer pour chaque processus :

a) TR (Le temps de réponse)
b) TA (Temps d’attente)
3) Calculer le temps moyen :
a) TRM(temps de réponse moyen)
b) TAM(le temps d’attente moyen)

2
 Processus Temps de séjour Date
d’arrivée
Solution : P1 3 0
P2 2 2
FIFO (First in First Out),
P3 4 3
P4 7 5
1.Diagramme
3 2 4 7
P1 P2 P3 P4
0 3 5 9 16
2. Calculer pour chaque processus :
a)TR (Le temps de réponse)
TR(P1)=3-0=3
TR(P2)=5-2=3
TR(P3)=9-3=6 3. Calculer le temps moyen :
TR(P4)=16-5=11 3+3+6+11 23
b)TA (Temps d’attente) a) TRM= = =5,75
TA(P1)=3-3=0 4 4
TA(P2)=3-2=1 0+1+2+4 7
TA(P3)=6-4=2 b) TAM = = =1,75
TA(P4)=11-7=4 4 4
3
 Exercice 2: SJF sans réquisition ( non préemptif)

Soit un système monoprocesseur

Durée Date
ordonnance l’exécution des processus Processus d’exécution d’arrivée
par un 'algorithme SJF sans réquisition
du tableur suivant:
P1 7 0

1)Tracer un diagramme illustrant l’exécution des

P2 5 1
processus
P3 4 2
2) Calculer pour chaque processus :
a) TR (Le temps de réponse) P4 8 3
b) TA (Temps d’attente)
3) Calculer le temps moyen :
a) TRM(temps de réponse moyen)
b) TAM(le temps d’attente moyen)
4
 Solution: SJF sans réquisition ( non préemptif)
Durée d’exécution Date
Processus d’arrivée

 TRI= TEMPS FIN D'EXÉCUTION - DATE D'ARRIVÉE

 TRM= σ𝒏𝒊=𝟎 𝑻𝑹𝒊/𝒏

P1 7 0
P2 5 1
 TAI= TRI - TEMPS D'EXÉCUTION
P3 4 2
 TAM= σ𝒏𝒊=𝟎 𝑻𝑨𝒊/𝒏
P4 8 3
1)Diagramme de GANTT:
7 4 5 8
P1 P3 P2 P4
0 7 11 16 24

2) 3)
a) b)
TR(p1)=7-0=7
a)
TA(p1)=7-7=0 7+15+9+21 52
TRM= = = 13
TR(p2)=16-1=15 TA(p2)=15-4=11
4 4
TR(p3)=11-2=9 TA(p3)=9-5=4
TR(p4)=24-3=21 TA(p4)=21-8=13 b) 0+11+4+13 28
= = 7
TAM=
4 4
5
Exercice 2:
Soit un système monoprocesseur ordonnance l’exécution des processus par
un 'algorithme SJF avec préemptif (Shortest Job First avec préemptif ) du
tableur suivant:
Processus Temps d’exécution Date d’arrivée priorité
P1 6 0 2
P2 5 1 3
P3 3 2 1
P4 2 3 4

1) Tracer un diagramme de GANTT illustrant exécution des processus

2) Calculer pour chaque processus :
a) TR (Le temps de réponse)
b) TA (Temps d’attente)
3) Calculer le temps moyen :
a) TRM(temps de réponse moyen)
b) TAM(le temps d’attente moyen)
Solution:
Processus Temps d’exécution Date d’arrivée priorité
P1 6 0 2
P2 5 1 3
P3 3 2 1
P4 2 3 4

1)
0 1 2 3 5 9 14 16
P1 P3 P1 P2 P4
2)
b) 3)
a)
TA(P1)=10-6=4 a) TAM=39/4=9,75
TR(P1)= 10-0=10
TR(P2)=14-1=13 TA(P2)=13-5=8
TA(P3)=3-3=0 b) TRM=23/4=5,75
TR(P3)=5-2=3
TR(P4)=16-3=13 TA(P4)=13-2=11
TR=10+13+3+13=39 TA=4+8+0+11=23
Exercice 3:
Soit un système monoprocesseur ordonnance l’exécution des
processus par un ‘algorithme tournique (ROUND ROBIN) avec un
quantum de 8ms du tableur suivant:

1. Tracer un diagramme illustrant exécution des processus

2. Calculer le temps de réponse pour chaque processus
3. Calculer le temps d’attente pour chaque processus
4. Calculer le temps de réponse TRM et le temps d’attente moyen
TAM de l’ensemble des processus
8
Solution: Algorithme tournique (ROUND ROBIN) avec un quantum de 8ms
Processu Temps Date d’arrivée
s d’exécution

P1 18 Tous les
P2 9 processus
sont arrives
P3 16 au même
P4 7 temps

1) Diagramme

P1 P2 P3 P4 P1 P2 P3 P1

0 8 16 24 31 39 40 48 50
2) 3)
TR(P1)=50-0=50 TA(P1)=50-18=32
TR(P2)=40-0=40 TA(P2)=40-9=31
TR(P3)=48-0= 48 TA(P3)=48-16=32
TR(P4)=31-0= 31 TA(P4)=31-7= 24
TR=50+40+48+31=169 TA=32+31+32+24=119

4) TRM=169/4=42,25 TAM=119/4=29,75 9
Exercice 4:

Etant donné 5 partitions de mémoire libres

dans l'ordre de 100k, 500k, 200k, 300k et 600k. les
processus qui arrivent occupent un espace de
mémoire de 212K, 417K, 112K et 426K.
1. Présenter les processus selon les algorithmes:
a) FIRST FIT
b) BEST FIT
c) WORST FIT
2. Calculer l’espace avec fragmentation interne pour
chaque algorithme
10
 Solution:

1- First fit: Best fit: Worst fit:

959k 533k 959k
100 k 100 k 100 k

500 k P1 500 k P2 500 k P2

200 k P3 200 k P3 200 k

300 k 300 k P1 300 k P3

600 k P2 600 k P4 600 k P1

Fragmentation interne:559k Fragmentation interne:433 k Fragmentation interne : 659k

P4:426k n’a pas de place P4:426k n’a pas de 11
place
Exercice 5:

Soit les partitions de mémoire libres sont 90K,40K,

75K et 105K ,les processus qui arrivent
demandent un espace de mémoire de 85K, 135K,
95K et 45K.
1-Présenter les processus selon les algorithmes
(First Fit), (Best Fit) et (Worst Fit).
2-Quel est le meilleur algorithme dans ce cas ?

12
Solution
85k 135k 95K 45K
1-
P2 P1 P3
First fit:
40k 90 75

P4:105k n’a pas de place

85k 135k 95K 45K
Best fit: P3 P4 P1 P2
75k 105 85 40

Worst fit: 85k 135k 95K 45K

P3 P1 P2
75k 90 40
P4:105k n’a pas de place

2- Le meilleur algorithme the best fit

13
 Exercice 5:
Soit les partitions libres sont 90K,40K, 75K et 105K ,les processus qui arrivent
demandent 85K, 135K, 95K et 45K.
1-Présenter les processus selon les algorithmes (First Fit), (Best Fit) et (Worst Fit).
2-Quel est le meilleur algorithme dans ce cas ?
Solution: 85k 135k 95K 45K
1-
P2 P1 P3
First fit:
40k 90 75

P4:105k n’a pas de place

85k 135k 95K 45K
Best fit: P3 P4 P1 P2
75k 105 85 40

Worst fit: 85k 135k 95K 45K

P3 P1 P2
75k 90 40
P4:105k n’a pas de place
14
2- Le meilleur algorithme the best fit
 Exercice 6 :

Gestion de la mémoire par subdivision (Buddy System)

Donner la simulation de la gestion d'une mémoire initialement vide, de taille 1Mo, en
utilisant l’allocation par zones siamoises en subdivision binaire (Buddy system binaire)
pour les demandes d'allocation (+) et de libération (-) suivantes :+80K, +40K, +95K, -80K,
+60K, -40K, -60K

NB: A,B,C et D sont des processus qui arrivent comme suit:

A demande 80Ko
B demande 40 Ko
C demande 95 Ko
D demande 60 Ko:

 Allocation et libération très simple

 Fragmentation Interne. Un processus demandant 2n +1 (Ex. 129) aura
un bloc de 2n+1 (ex. 256)

15
 Solution:
Avec une mémoire de 1 Mo.
Initialement, la mémoire est vide. Toutes les listes sont vides, sauf la liste 1 Mo qui pointe sur la zone libre de 1 Mo :

1Mo=1024 Ko

Un processus A a demandé 80 Ko : la mémoire est fragmentée en deux segments de 512 Ko ; l'un d'eux est fragmenté
en deux blocs de 256 Ko ; l'un de ces deux derniers est fragmenté en deux blocs de 128 Ko et on loge A dans l'un d'eux,
puisque 64 < 80 < 128 (26<80<27) :

⁻ Introduction d’un processus A de taille 80 ko A 128 ko 256 ko 512 ko

Un processus B demande 40 Ko : l'un des deux blocs de 128 Ko est fragmenté en deux de
64 Ko et on loge B dans l'un d'eux puisque 32 < 40 < 64 (25<40<26) :
⁻ Introduction d’un processus B de taille 40 ko A B 64 256 ko 512 ko

Un processus C demande 95 Ko : le bloc de 256 Ko est fragmenté en deux de 128 Ko et on loge C dans l'un d'eux
puisque 64 < 95 < 128 (26<95<27) :
⁻ Introduction d’un processus C de taille 95 ko A B 64 C 128 ko 512 ko

Libre Allouée Fragmentation

16
Avec une mémoire de 1 Mo.
Initialement, la mémoire est vide. Toutes les listes sont vides, sauf la liste 1 Mo qui
pointe sur la zone libre de 1 Mo :
1Mo=1024 Ko

A s'achève et libère son bloc de 128 Ko. Puis un processus D demande 60 Ko : le bloc libéré par A est fragmenté en
deux de 64 Ko, dont l'un logera D :

D 64 B 64 c 128 512 ko

B s'achève, permettant la reconstitution d'un bloc de 128 Ko :

D 64 128 c 128 512 ko

D s'achève, permettant la reconstitution d'un bloc de 256 Ko, etc...

256 c 128 512 ko

17