VI - La mémoire virtuelle

23
 La mémoire virtuelle : introduction
• Il y a de nombreuses années, les programmes étaient trop volumineux pour
entrer dans la mémoire disponible
• La solution adoptée fut de diviser le programme en parties appelées des
segments de recouvrement (overlays)
• Le segment 0 s’exécute en premier, lorsqu’il se termine il appelle un autre
segment
• Les segments de recouvrement étaient stockés sur le disque et effectuaient
des va-et-vient
• Le SE effectuait les déplacements, mais le découpage du programme devait
être fait par le programmeur : long et fastidieux
• On adopta alors le principe de la mémoire virtuelle
• Idée de base : la taille du programme peut dépasser la taille de la mémoire
disponible, le SE garde en mémoire les parties du programme qui sont
utilisées, stocke le reste sur disque et effectue des va-et-vient lorsqu’il a
besoin d’informations stockées sur disque
24
 L’allocation de l’espace
de va-et-vient
• Dans certains systèmes, on n’alloue pas à l’avance un espace
fixe sur le disque aux processus qui sont en mémoire
• Quand un processus doit être copié sur disque, on lui attribue
un espace de va-et-vient (swap area)
• A chaque va-et-vient, le processus peut être placé à un
endroit différent sur le disque, les algos de gestion de l’espace
de va-et-vient sont identiques à ceux de la gestion de la
mémoire principale
• Sur d’autres systèmes, lors de la création d’un processus, on
lui alloue un espace fixe de va-et-vient ; chaque fois qu’il est
déplacé sur disque, il est placé dans l’espace qui lui est
réservé ; cet espace est libéré lorsque le processus se termine
• La seule différence entre l’espace mémoire et l’espace swap
est que l’espace swap d’un processus est un nombre entier de
blocs du disque
25
 La pagination (1)
• La plupart des systèmes à mémoire virtuelle ont recours à la pagination
• Les adresses alors manipulées par les programmes sont appelées des
adresses virtuelles et constituent l’espace d’adressage virtuel
• Sur les ordinateurs sans mémoire virtuelle, les adresses sont
directement placées sur le bus de la mémoire et provoquent la lecture
ou l’écriture du mot à l’adresse spécifiée
• Lorsque la mémoire virtuelle est utilisée, les adresses sont envoyées à
l’unité de gestion de la mémoire ou MMU (Memory Management Unit),
composant qui traduit les adresses virtuelles en adresses physiques
Carte processeur Le processeur envoie des adresses virtuelles au MMU

CPU Contrôleur
Mémoire
MMU de disque
Le MMU envoie des
adresses physiques à la
BUS
mémoire
26
 La pagination (2)
• Ex : ordinateur disposant de 32k de mémoire pouvant générer des adresses virtuelles
de 16 bits de 0 à 64k Espace
des Adresse
• On peut donc écrire des programmes de adresses mémoire
virtuelles physique
64k, mais on ne peut les charger 0k - 4k 2 0k - 4k
entièrement en mémoire 4k - 8k 1 4k - 8k
8k - 12k 6 8k - 12k
• Une image mémoire de tout le programme 12k - 16k 0 12k - 16k

est stockée sur disque de telle sorte qu’on 16k - 20k

20k - 24k
4
3
16k - 20k
20k - 24k
puisse en charger, au besoin, les 24k - 28k X 24k - 28k

différentes parties dans la mémoire 28k - 32k

32k - 36k
X
X
28k - 32k

• L’espace d’adressage est divisé en petites 40k - 44k

36k - 40k 5
X
unités appelées pages 44k - 48k 7 case physique
48k - 52k X
• Les unités correspondantes de la 52k - 56k X
mémoire physique sont les cases 56k - 60k X page virtuelle
60k - 64k X
mémoire (page frames)
• Les pages et les cases sont toujours de la même taille
• Les transferts entre la mémoire et le disque se font toujours par page entière

27
 La pagination (3)
• Ex : MOV reg,0 (lecture de la valeur contenu à l’adresse 0)
– L’adresse virtuelle 0 est envoyée au MMU
– Ce dernier constate que cette adresse virtuelle se situe à la page 0
(adresses de 0 à 4096) qui appartient à la case 2 (8192 à 12387)
– Le MMU transforme l’adresse en 8192 et place cette valeur sur le bus
– La carte mémoire ne connaît pas l’existence du MMU, elle reçoit
simplement une demande de lecture de l’adresse 8192
• Le MMU a donc mappé les adresses virtuelles comprises
entre 0 et 4096 sur les adresses physiques comprises entre
8192 à 12387
• De la même manière l’adresse virtuelle 8192 est transformée
en 24576 et 20500 correspond à l’adresse physique 12308
• Ce mappage au moyen du MMU des 16 pages virtuelles sur
n’importe laquelle des 8 cases ne résout pas le problème
soulevé par le fait que l’espace d’adressage virtuel est plus
grand que la mémoire physique
28
 La pagination (4)
• Les pages signalées par un « X » ne sont pas mappées
• Le matériel mémorise dans un bit de présence si une page est
mappée ou non
• Que se passe-t-il si le programme tente d’utiliser une page
non mappée (ex : MOV reg, 32780)
• Le MMU constate que cette page n’est pas mappée et
provoque un déroutement (trap) : le processeur est restitué
au SE
• Ce déroutement est appelé défaut de page (page fault)
• Le SE repère une case peu utilisée et recopie son contenu sur
le disque ; il place ensuite la page demandée dans la case qui
vient d’être libérée, modifie le mappe et réexécute
l’instruction déroutée

29
 Fonctionnement interne du MMU
• Lorsque le MMU reçoit une adresse, il divise celle-ci en 2 parties : le numéro de page et un
déplacement dans cette page
0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 Adresse virtuelle
• Dans notre exemple : numéro de page = 4 en entrée (8196)
bits de poids fort et le déplacement est La page virtuelle 2 sert d'index
stocké sur 12 bits dans la table des pages
0 010 1
• Les 4 bits du numéro de page permettent 1 001 1
d’avoir 16 pages et les 12 bits du 2
3
110
000
1
1
110

déplacement permettent d’adresser les 4 100 1 Déplacement de 12 bits

4096 octets d’une page 5
6
011
000
1
0
recopié directement de
l'entrée à la sortie
• Le numéro de page sert d’index dans la 7 000 0
8 000 0
table des pages et donne la case qui 9 101 1
correspond à cette page virtuelle 10 000 0 Table des pages
11 111 1
• Si le bit de présence est à 0, il y a 12 000 0

déroutement, sinon on copie le numéro de 13

14
000
000
0
0
la case dans les 3 bits de poids fort du 15 000 0

registre de sortie et le déplacement fourni

par l’adresse virtuelle Adresse physique
0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 en sortie (24580)

• Le registre de sortie contient l’adresse physique et peut être placé sur le bus de la mémoire
30
 Les tables de pages (1)
• Le but de la table de pages est d’établir la correspondance entre
les pages virtuelles et les cases mémoires
• D’un point de vue mathématique, c’est une fonction qui prend
en argument un numéro de page virtuelle et renvoie un numéro
de case mémoire
• Cependant les deux points suivants doivent être pris en compte :
– La table des pages peut être très grande
– Le mappage doit être rapide
• Le premier point découle de l’adressage des ordinateurs
modernes qui utilisent des adresses virtuelles de 32 bits ou +
• En utilisant des pages de 4ko, un espace d’adressage de 32 bits a
1 million de pages
• Si l’espace d’adressage virtuel a 1 million de pages, la table des
pages doit comporter 1 million d’entrées !
31
 Les tables de pages (2)
• Par ailleurs, chaque processus a besoin de sa propre
table des pages !
• Le deuxième point découle du fait que le mappage de
l’adresse virtuelle sur l’adresse physique doit être
effectué à chaque référence mémoire ; une instruction
typique comporte une instruction sur un mot et souvent
un opérande mémoire ; en conséquence il est
nécessaire d’effectuer, une, deux ou davantage de
références à la table des pages par instruction
• Si une instruction prend 10ns, la recherche dans la table
des pages doit être effectuée en quelques
nanosecondes pour éviter un ralentissement important
• La conception de la tables des pages est donc un point
crucial quant à l’efficacité de l’ordinateur 32
 La table des pages (3)
• La conception la plus simple consiste à avoir une seule
table des pages constituée d’un tableau de registres
machine rapides, avec une entrée par page virtuelle et
indexation au moyen du numéro de page virtuelle
• Lorsqu’un processus est activé, le SE charge les
registres avec la table des pages de ce processus ; au
cours de l’exécution la table des pages ne nécessite
plus de références mémoire
• Cette méthode est simple à réaliser et ne requiert pas
de références mémoire pendant le mappage ; elle
peut, en revanche, être coûteuse (si la table des pages
est grande) et le chargement de la table des pages à
chaque changement de contexte peut également être
pénalisant
33
 La table des pages (4)
• A l’autre extrême, la table des pages peut résider
intégralement en mémoire. Le matériel n’a alors
besoin que d’un seul registre qui pointe sur le début
de la table des pages
• Cette conception permet de changer la mappe
mémoire en modifiant un seul registre lors d’un
changement de contexte; elle présente bien sûr le
désavantage de nécessiter une ou plusieurs
références mémoire pour lire les entrées de la table
des pages lors de l’exécution de chaque instruction
• Pour cette raison, cette approche est rarement utilisée
dans sa forme initiale
34
 La table des pages
à plusieurs niveaux
• Pour éviter d’avoir des tables trop
Table des pages
de second niveau

grandes en mémoire, de nombreux

ordinateurs utilisent des tables de pages
à plusieurs niveaux
• Ex : adresse virtuelle divisée en un Table des pages

champ PT1 de 10 bits, un champ PT2 de

de plus haut niveau

10 bits et un champ déplacement de 12 1

2

bits (=> 220 pages de 4Ko) PT1

3
4
5

• Les tables des pages à plusieurs niveaux 6

7

évitent de garder en permanence toutes

.
.
.
les tables des pages en mémoire ; en 1023

particulier, celles qui ne sont pas utilisées

ne devraient pas être gardées en 0
mémoire 1
2

• Ex: un prog de 12Mo divisé en 3 parties

3
4 Table des pages
5 des 4 Mo du haut

de 4Mo 6
7
de la mémoire

.
.
. 35
1023
 La mémoire associative
• Les tables des pages des mémoires paginées sont souvent
gardées en mémoire en raison de leur tailles importantes ce qui
occasionne un coût non négligeable sur la vitesse des
ordinateurs
• Les concepteurs d’ordinateurs sont conscients de ce problème
et y ont remédié
• La solution mis en œuvre s’appuie sur la constatation que la
plupart des programmes effectuent un grand nombre de
références à un petit nombre de pages ; de ce fait, une petite
fraction des entrées de tables des pages sont souvent lues et les
autres sont rarement utilisées
• La solution consiste à doter les ordinateurs d’un composant
matériel pour mapper les adresses virtuelles sur les adresses
physiques sans passer par la table des pages
• Ce composant est appelé mémoire associative (ou parfois
mémoire tampon de translation ) 36
 La mémoire associative
• Elle est en général intégré au MMU et consiste en un petit
nombre d’entrées (32) contenant les informations relatives à
une page
• Lorsqu’une adresse est présentée au MMU le matériel contrôle
d’abord si le numéro de page virtuelle est présent dans la
mémoire associative ; s’il le trouve la case mémoire est prise
directement dans la mémoire associative sans passer par la
table des pages; sinon le MMU effectue une recherche
ordinaire dans la table des pages, puis il supprime une des
entrées de la mémoire associative et la remplace par l’entrée
récemment trouvée
• La fraction de références mémoire trouvées dans la mémoire
associative est appelée taux d’impact (hit ratio), les
performances sont d’autant meilleures qu’il est élevé

37
 Algorithmes de
remplacements de page
• A la suite d’un défaut de page, le SE doit retirer une page de la
mémoire pour libérer de la place pour la page manquante
• Si la page a été modifiée depuis son chargement en mémoire,
il faut réécrire sur le disque ; sinon le disque est déjà à jour, la
page lue remplace simplement la page à supprimer
• La page à supprimer peut être choisie au hasard mais on
améliore sensiblement les performances du système si on
choisit une page peu utilisée
• Si on sélectionne une page très demandée, il est probable
qu’il faille la ramener rapidement en mémoire, ce qui entraîne
une perte de temps inutile

38
 Algorithme de remplacement
de page optimal
• Le meilleur algorithme de remplacement est facile à décrire
mais impossible à mettre en œuvre
• Il consiste à associer à chaque page le nombre d’instructions qui
vont être exécutées avant que la page soit référencée
• L’algorithme de remplacement page optimal consiste à retirer la
page qui a le plus grand nombre
• Malheureusement cet algo est irréalisable car le SE ne peut pas
connaître à l’avance le moment où les différentes pages seront
référencées
• On peut implanter cet algorithme en exécutant le programme
sur un simulateur qui mémorise toutes les références aux pages
lors d’une 1re exécution et qui utilise ces informations lors d’un
39
2 exécution
ème
 Algorithme de remplacement
d’une page non récemment utilisée
• Pour effectuer des statistiques sur les pages utilisées, les
ordinateurs associent à chaque page 2 bits d’information :
– Le bit R est positionné chaque fois qu’une page est référencée
– Le bit M est positionné quand on écrit dans une page
• Ces bits devant être mis à jour à chaque référence mémoire, il
est essentiel que ce soit fait par le matériel ; dès qu’un bit est
mis à 1, il reste dans cet état jusqu’à ce que le SE le remette à
0
• Ces 2 bits permettent de construire l’algo de pagination
suivant :
– Au lancement d’un processus, le SE met à 0 les bits de toutes ses
pages, périodiquement (par ex, à chaque interruption d’horloge), le bit
R est remis à 0 pour différencier les pages récemment référencées des
autres

40
 Algorithme de remplacement
d’une page non récemment utilisée
• Lorsqu’un défaut se produit, le SE parcourt toutes pages et les répartit en
4 catégories en fonction des valeurs de R et M :
• Catégorie 0 : non référencée, non modifiée
• Catégorie 1 : non référencée, modifiée
• Catégorie 2 : référencée, non modifiée
• Catégorie 3 : référencée, modifiée
• L’algo de la page non récemment utilisée ou NRU (Not
Recently Used) retire une page au hasard de la catégorie non
vide de plus petit numéro
• NRU est facile à comprendre, relativement efficace et fournit
des performances qui sont souvent suffisantes même si elles
ne sont pas optimales

41
Algorithme de remplacement de page
premier entré, premier sorti
• Un deuxième algo qui requiert peu de temps
processeur est l’algorithme du premier entré,
premier sorti ou FIFO (First In First Out)
• Le SE mémorise une liste de toutes les pages en
mémoire, la première page de cette liste étant la plus
ancienne et la dernière la plus récente ; lorsqu’il se
produit un défaut de page, on retire la première page
de la liste et on place la nouvelle page à la fin de la
liste
• Cet algorithme fournit de piètre performance
42
Algorithme de remplacement de page
premier entré, premier sorti
• Pour l’illustrer, considérez un boutiquier qui possède k
étagères chacune pouvant contenir un produit différent ;
• Un fabriquant crée un nouveau produit qui a tellement
de succès que le boutiquier doit abandonner un ancien
produit pour le mettre en étalage.
• Le boutiquier décide de se séparer du produit qu’il vend
depuis le plus longtemps. Si ce produit est le sel, la farine
ou le sucre il est clair que ce choix est mauvais !
• Pour cette raison, l’algorithme FIFO est rarement utilisé
dans sa forme originale
43
 Algorithme de remplacement
de page de la seconde chance
• Une modification simple de FIFO, pour éviter de retirer une
page très référencée, consiste à tester le bit R de la page la
plus ancienne :
– S’il est à 0, la page est à la fois âgée et non utilisée et peut donc être
remplacée immédiatement
– S’il est à 1, la page est placée à la fin de liste des pages et son temps
de chargement est mis à jour comme si elle venait d’être chargée en
mémoire ; puis la recherche se poursuit
• L’algorithme de la seconde chance cherche donc une ancienne
page qui n’a pas été référencée au cours du dernier top
d’horloge
• Si toutes les pages ont été référencées, l’algo de la seconde
chance est équivalent au FIFO, puisque les bits de chaque
page seront mis à 0 et la plus ancienne page sera remplacée 44
 Algorithme de remplacement
de page de l’horloge
• L’algorithme de la seconde chance n’est pas suffisamment efficace car il
déplace en permanence des pages dans une liste
• Une meilleure solution consiste à garder les pages dans une file circulaire en
forme d’horloge
A Lorsqu’un défaut de page se produit,
A A
A A la page pointée est testée.
A A L’action entreprise dépend du bit R :
A A • R=0 : retirer la page
A A • R=1 : mettre R à 0 et avancer pointeur
A
• Lorsqu’un défaut de page se produit, la page pointée par l’indicateur est examinée ; si
R=0, la page est retirée, la nouvelle est insérée à sa place dans l’horloge et
l’indicateur avancé d’une position ; si R=1, il est mis à 0 et l’indicateur pointe sur la
page suivante ; cette opération est répétée jusqu’à ce qu’une page ayant R=0 soit
trouvée
• Cet algo, appelé horloge, ne diffère de l’algorithme de la seconde chance qu’au
niveau de la mise en oeuvre 45
 Algo de remplacement de la page la
moins récemment utilisée (1)
• Une bonne approximation de l’algo optimal se fonde
sur l’observation que les pages les plus référencées
au cours des dernières instructions seront
probablement très utilisées au cours des prochaines
• A l’inverse, les pages qui n’ont pas été référencées
pendant un long moment ne seront pas
probablement demandées pendant un certain temps
• Cette observation suggère l’algo qui, lorsqu’il se
produit un défaut de page , supprime la page qui est
restée inutilisée pendant le plus de temps
• Cette stratégie est celle de la page la moins
récemment utilisée ou pagination LRU (Least
Recently Used)
46
 Algo de remplacement de la page la
moins récemment utilisée (2)
• LRU est théoriquement réalisable mais il est très
coûteux, il faut en effet mémoriser une liste chaînée
de toutes les pages en mémoire, la page la plus
utilisée étant en tête et la moins utilisée en queue
• La difficulté vient du fait que cette liste doit être mise
à jour chaque fois que la mémoire est adressée :
trouver une page dans la liste, la supprimer puis la
déplacer au début de la liste sont des opérations qui
consomment beaucoup de temps CPU
• Il faut soit avoir du matériel spécialisé (et onéreux),
soit trouver une approximation logicielle moins
coûteuse

47
 Algo de remplacement de la page la
moins récemment utilisée (3)
• La recherche et la modification d’une liste chaînée à
chaque instruction prennent du temps même lorsque
ces opérations sont effectuées matériellement
• Il existe néanmoins d’autres moyens pour mettre en
œuvre LRU en faisant toujours appel à du matériel
spécialisé
• La méthode la plus simple consiste à disposer d’un
compteur C de 64 bits qui est automatiquement
incrémenté à chaque instruction ; de plus chaque
entrée dans la table des pages doit avoir un champ
suffisamment grand pour contenir ce compteur

48
 Algo de remplacement de la page la
moins récemment utilisée (4)
• Chaque fois que la mémoire est adressée, la valeur courante
de C est sauvegardée dans l’entrée de la page référencée
• Lorsqu’un défaut se produit, le SE examine tous les
compteurs de la table des pages pour trouver le plus petit
d’entre eux : la page correspondante est la moins récemment
utilisée
• Une seconde solution matérielle consiste à disposer d’un
matériel mémorisant une matrice de nn bits initialement
nulle
• Quand une page k est référencée, le matériel positionne tous
les bits de la rangée k à 1 puis tous les bits de la colonne k à 0
• A tout instant la ligne contenant le – de 1 indique la page la
moins récemment utilisée
49
 Algo de remplacement de la page la
moins récemment utilisée (3)
Exemple : 4 cases et les références aux pages suivantes : 0 1 2 3 2 1
0323
0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3 0 1 2 3

0 0 1 1 1 0 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0

1 0 0 0 0 1 0 1 1 1 0 0 1 1 0 0 0 1 0 0 0

2 0 0 0 0 0 0 0 0 1 1 0 1 1 1 0 0 1 1 0 1

3 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0

0 0 0 0 0 0 1 1 1 0 1 1 0 0 1 0 0 0 1 0 0

1 1 0 1 1 0 0 1 1 0 0 1 0 0 0 0 0 0 0 0 0

2 1 0 0 1 0 0 0 1 0 0 0 0 1 1 0 1 1 1 0 0

3 1 0 0 0 0 0 0 0 1 1 1 0 1 1 0 0 1 1 1 0

50
 Simulation logicielle de l’algo LRU
• Les 2 algorithmes précédents sont réalisables mais font appel à
du matériel spécialisé, si l’on dispose pas de ce matériel, il faut
trouver une solution logicielle : l’algorithme de la page peu
utilisée ou NFU (Not Frequently Used)
• Il nécessite un compteur par page, ce compteur est initialement
à0
• A chaque interruption d’horloge, le système d’exploitation passe
en revue toutes les pages en mémoire et le bit R est ajouté à son
compteur
51
 Simulation logicielle de l’algo LRU
• Les compteurs mémorisent donc le nombre de fois où on
référence les différentes pages; quand il se produit un défaut de
page, on remplace la page dont le compteur est le plus petit
• Le problème de NFU est qu’il n’oublie jamais rien (des pages
énormément utilisées au début processus et qui ne sont plus
utilisées resteront probablement mappé)
• Il existe une légère modification qui permet à NFU de se
comporter comme LRU

52
 Algorithme du veillissement

• Cette modification se fait en deux temps :

– Décaler les compteurs vers la droite avant de les
additionner
– Le bit R est additionné au bit de gauche (de poids fort)
• Ce nouvel algorithme s’appelle l’algorithme du
vieillissement (aging)
• A la suite d’un défaut de page, on retire la page qui a
le plus petit compteur

53
 Algorithme du veillissement
• Cet algorithme diffère de LRU en deux points :
– En mémorisant qu’un seul bit par intervalle de temps, on
ne peut distinguer les références qui se produisent au
début de l’intervalle de celles qui se produisent à la fin
(idem pour le nombre de références à une même page
durant un top d’horloge)
– Le compteur de l’algorithme du vieillissement a un nombre
fini (n) de bits ; supposez que 2 pages qui ont leurs
compteurs à 0, il faut choisir au hasard alors qu’il se peut
qu’une des 2 pages ait été référencé n+1 tops plus tôt et
l’autre 10n tops plus tôt : il n’y a aucun moyen de le savoir
• Dans la pratique un compteur de 8 bits est suffisant
si les tops d’horloge se produisent toutes les 20 ms
(si un page n’est pas référencée depuis 160 ms, elle
n’est vraisemblablement plus utilisée) 54
 Segmentation
• Il existe une alternative à la pagination pour obtenir
de la mémoire virtuelle : la segmentation
– Elle consiste à segmenter le processus (comme pour les
partitions variables)
– L’adressage virtuelle est obtenu en donnant un numéro de
segment et une adresse dans ce segment
– La segmentation peut également être paginée, on parle de
segmentation avec pagination

55
Fin

56
 Exercice
• On dispose d’une mémoire composé de trois
cases. Soit les requêtes des pages suivantes dans
l’ordre :

Présenter sur un tableau les états de cette mémoire

suivant les politiques de remplacements de pages :
1. FIFO
2. Page optimal
3. LRU

57