Vous êtes sur la page 1sur 8

1CS_ESI Avril 2021

TD3 de Systèmes d’exploitation


Pagination à la demande
Corrigé

Exercice 1 :

TAE = 80%*(6+40) + 20%*( 90%*(6+2*40) + 10%((6+40) + (100*10+3 +10*10+6) + 6+2*40 ))


= 80%*46 + 18%*86 + 2%(46 + 100*10+3 + 10*10+6 + 86 )
= 36,8 + 15,48 + 0,02*(132 + 100*10+3 + 10*10+6 ) = 52,28 + 2,64 + 2000 + 200000

= 202054,92 ns 5051,4 accès mémoire !
Exercice 2 :
long int A[1024][1024];
int i,j;

Initialisation (a) Initialisation (b)


for(j=0; j<1024; j++) for(i=0; i<1024; i++)
for(i=0; i<1024; i++) for(j=0; j<1024; j++)
A[i][j] = 0; A[i][j] = 0;


Taille du tableau : 4*1024*1024octets ; 4*1024*1024 /4*1024 = 1024 pages.

Une ligne 1024*4 octets Une page.

Séquence a) : La matrice est traitée colonne par colonne


Pour une colonne, on parcourt toutes les lignes (1024 lignes par colonne), Une

page contient une ligne, donc on fait un défaut de pages par ligne 1024
défauts de pages par colonne.
Le nombre de défaut de pages est égal à 1024*1024 = 1048576.

Séquence b) : la matrice est traitée ligne par ligne


Une page contient une ligne ; on fait un défaut par ligne.

Il y a 1024 lignes Le nombre de défaut de pages est égal à 1024.

Exercice 3:
Taille du tableau A[64,64] : (64*64)/256 = 16 pages(page1 à page16).
Une colonne = 64 ➔ 4 colonnes sur une page.
Matrice en mémoire colonne/colonne
Programme Page0
colonne 0 et 3 Page1
colonne 4 et 7 Page2
… …
colonne 60 et 63 Page16
Chaîne de références
A[0, 48], A[48, 0], A[16, 48], A[48, 16], A[32, 48], A[48, 32],
A[0, 36], A[36, 0], A[16, 36], A[36, 16], A[32, 36], A[36, 32],
A[0, 24], A[24, 0], A[16, 24], A[24, 16], A[32, 24], A[24, 32].
N° page=partie entière[(ligne+colonne*64)/256]+1 (le tableau commence à partir de la page1)
= 0 ; 13, 1, 13, 5, 13, 9; 10, 1, 10, 5, 10, 9; 7, 1, 7, 5, 7, 9.
= 0 ; 13, 1, 13, 5, 13, 9, 10, 1, 10, 5, 10, 9, 7, 1, 7, 5, 7, 9.
Algorithme de l’horloge
13 1 13 5 13 9 10 1 10 5 10 9 7 1 7 5 7 9
Case1 13 13 13 9 9 9 5 5 5 1 1 9
Case2 1 1 1 10 10 10 10 7 7 7 7
Case3 5 5 5 1 1 9 9 9 5 5
D.P. X x x x x X x x x x x x
Nombre de défauts de page = 1 + 12 = 13

Exercice 4 :
a)
FIFO 0 1 4 2 1 5 4 0 5 1 4 2
Case1 0 0 0 0 0 5 5 5 5 2
Case2 1 1 1 1 1 0 0 0 0
Case3 4 4 4 4 4 1 1 1
Case4 2 2 2 2 2 4 4
DP=9 x x x x x x x x x

LRU 0 1 4 2 1 5 4 0 5 1 4 2
Case1 0 0 0 0 0 5 5 5 5 5 5 5
Case2 1 1 1 1 1 1 1 1 1 1 1
Case3 4 4 4 4 4 4 4 4 4 4
Case4 2 2 2 2 0 0 0 0 2
DP=7 x x x x x x x

OPT 0 1 4 2 1 5 4 0 5 1 4 2
Case1 0 0 0 0 0 0 0 0 0 0 0 2
Case2 1 1 1 1 1 1 1 1 1 1 1
Case3 4 4 4 4 4 4 4 4 4 4
Case4 2 2 5 5 5 5 5 5 5
DP=6 x x x x x x

Horloge 0 1 4 2 1 5 4 0 5 1 4 2
Case1 →01 →01 →01 →01 →01 51 51 51 51 →51 →51 21
Case2 11 11 11 11 →10 →10 01 01 01 01 →00
Case3 41 41 41 40 41 →41 →41 40 41 40
Case4 21 21 20 20 20 20 11 11 10
DP=8 X x x x x x x x
L’algorithme de remplacement de page qui provoque 8 défauts de pages, après son
exécution avec cette chaîne de référence est : l’algorithme de l’horloge ou algorithme de
seconde chance.
Etat de la mémoire après l’exécution de l’algorithme de l’horloge :
Horloge 0 1 4 2 1 5 4 0 5 1 4 2
Case1 0 0 0 0 0 5 5 5 5 5 5 2
Case2 1 1 1 1 1 1 0 0 0 0 0
Case3 4 4 4 4 4 4 4 4 4 4
Case4 2 2 2 2 2 2 1 1 1
DP=8 x x x x x x x x

DP = x défaut de page Nombre de défauts de page = 8

b-1) Page = 128


= 901, 050, 127, 128, 129, 130, 150, 260, 261, 263, 060, 061, 062, 403, 404, 068, 524, 525, 526,
300, 301, 400, 404, 68, 450, 383, 255, 380, 127, 255, 1023, 120, 200.

= 7 00 1 1 1 1 2 2 20 0 0 3 3 0 4 4 4 2 2 3 3 0 3 2 1 2 0 1 7 0 1

= 7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

b-2) m=384/128 = 3 cases ;


On utilise une file 3 trois éléments (m=3 cases) : Chaque élément de la file contient :[ le bit de
référence R et le N° de la page ] ;
Pour éviter les erreurs , on utilise les valeurs ‘f’ et ‘v’ à la place de 0 et 1 comme valeurs du bit R.
Position du pointeur = élément en gris.
Algorithme de l’horloge(Seconde chance)

v 3 v/f 0 v 2 ; v 2 f 1 v 0 ; V 2 f 1 f 0 ; v 1 v 0 v 7

v 0 F 2 f 4 ; v 2 v 4 v 3 ; V 2 v 4 f 3 ; v 4 f 3 f 0

v 2 V 1 f 3 ; v 1 f 3 f 0 ; V 3 v 0 v 2 ; v 3 1 0 f 2

v 1 V 7 v 0 ; v 7 v 0 f 2 ; V 7 f 0 f 2 ; v 0 v 2 v 1
’v/f ’ : Le bit R était à ‘f’ et il est passé à ’v’ après une référence à la page correspondante.
Les 3 cases sont initialement vides.
7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1
Case0 7 7 7 2 2 4 4 4 3 3 3 0 0 0
Case1 0 0 0 0 0 2 2 2 1 1 1 7 7
Case2 1 1 3 3 3 0 0 0 2 2 2 1
DP=14 x x x x x x x x x x x x x x
Exercice 5 :
= 0, -1, -5, 0, 2 1, 2, -6, -5, 0 5, 1, -3, -1, -4 3, -6, -5, 0, 2 .
Nombre de cases initialement vide = 3.
Algorithme NRU :

Nombre de défaut de pages = 13.

Colonnes en gris : c’est un commentaire, pour voir le contenu de R et M au début du top de l’horloge.

Exercice 6:

Page Chargement Dernière R M FIFO LRUNRU Horloge


référence
11 110 260 1 0 Date de
chargement
12 120 211 0 1 Date de Date de chargement
référence et bit R
3 156 219 0 0 Bits R
et M
5 200 284 1 0
Exercice 7: Ecroulement du système
1) Nombre de processus =égal à 5 ; Algorithme LRU avec m=5 (5 cases vides)
Processus Pi+1 ; (i= 1) :
Chaîne des références du processus P2.
= 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, ...

5 6 7 8 9 5 6 7 8 9 5 6 7 8 9 5 6 7 8 9 5 6 7 8 9
Case0 5 5 5 5 5
Case1 6 6 6 6
Case2 7 7 7
Case3 8 8
Case4 9
DP=5 x x x x x
Quelque soit la longueur de la chaîne , le nombre de défauts de pages est égal à 5.
Taux de défauts de page tend vers 0%.2) Nombre de processus égal à 6 ; Algorithme LRU avec
m=4 (4 cases vides)
Processus Pi+1 (i= 1) : Chaîne des références du processus P2.
= 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, 5, 6, 7, 8, 9, ...
5 6 7 8 9 5 6 7 8 9 5 6 7 8 9 5 6 7 8 9 5 6 7 8 9
Case0 5 5 5 5 9 9 9 9 8 8 8 8 7
Case1 6 6 6 6 5 5 5 5 9 9 9 9
Case2 7 7 7 7 6 6 6 6 5 5 5
Case3 8 8 8 8 7 7 7 7 6 6
DP=| | x x x x x x x x x X x x x x x x x x x x x x … …
Il y a autant de défauts de page que de références mémoires.
Taux de défauts de page est égal à 100%.

Cet exercice explique le phénomène de l’écroulement du système :


La mémoire est allouée équitablement aux processus.
Le système fonctionnait bien avec cinq processus, en ajoutant un sixième processus (sans tenir
compte de la disponibilité de la mémoire centrale) on obtient la situation suivante :
• Augmentation du degré de multiprogrammation,
• Diminution du nombre de cases par processus,
• Accroissement du taux de défauts de page,
• Accroissement des échanges entre mémoire secondaire et mémoire centrale,
• Chute brutale du rendement du processeur (taux d’utilisation du processeur tombe au
niveau le plus bas).
Exercice 8 :
a)
Utilisation du Utilisation du Explications
processeur disque de pagination
13% 97% Il y a trop de défauts de pages : diminuer le
degré de multiprogrammation.
87% 3% Il y a très peu de défauts de pages et le taux
d’utilisation du processeur est bon. Si on
ajoute un processus on risque d’avoir un
écroulement du système (voir exercice4).
13% 3% Il y a très peu de défauts de pages et le taux
d’utilisation du processeur est très faible :
augmenter le degré de multiprogrammation.
b) Solution Matérielle : Rajouter de la mémoire physique(Augmenter la taille de la mémoire
principale).

Vous aimerez peut-être aussi