Systèmes d`exploitation Introduction Monoprogrammation

1
Systèmes d’exploitation
Gestion de la mémoire
Introduction
Mémoire ressource importante devant être gérée avec prudence
Gestion de la mémoire du ressort du gestionnaire de la mémoire
Ce gestionnaire doit :
– Connaître les parties libres et occupées de la mémoire
– Allouer de la mémoire aux processus qui en ont besoin
– Récupérer la mémoire utilisée par un processus lorsque celui-ci se termine
–Traiter le va-et-vient (swapping ou swap) entre le disque et la mémoire principale
lorsque cette dernière ne peut pas contenir tous les processus
Les systèmes de gestion de la mémoire se répartissent en 2 catégories :
1. Les systèmes qui déplacent les processus entre la mémoire principale et le disque (va-
et-vient et pagination)
2. Ceux qui ne le font pas
2ème catégorie + simple
Le va-et-vient et la pagination sont des artifices qui pallient à un manque de
mémoire princiaple
Monoprogrammation sans
va-et-vient ni pagination
Gestion de la mémoire la + simple consite à avoir un seul processus en mémoire à un instant
donné et lui permettre d’utiliser toute la mémoire disponible
La mémoire est partagée entre le SE et un unique processus utilisateur
L’IBM PC (i8086->i8486) utilise ce schéma :
– Les pilotes sont en ROM (Read Only Memory), les programmes en ROM sont appelés BIOS (Basic
Input Output System)
– Le SE se trouve en bas de la mémoire vive (RAM, Random Access Memory)
– Le programme utilisateur au-dessus du SE en RAM
Lorsque la mémoire est organisée de cette manière, il ne peut y avoir qu’un seul processus
s’exécutant à un instant donné
L’utilisateur tape une commande sur son terminal, le SE charge le programme en mémoire et
l’exécute ; lorsque le processus se termine le SE affiche une invite (prompt) sur le terminal et
attend la commande suivante pour char
g
er un nouveau processus qui remplace le précédent
Pilotes périphériques en ROM
Programme utilisateur
SE en RAM
Multiprogrammation et utilisation
de la mémoire : modélisation
La multiprogrammation permet d’améliorer le taux d’allocation du processeur
Supposons qu’un processus passe une fraction pde son temps à attendre la fin d’une
E/S ; si nprocessus se trouvent en mémoire en même temps, la probabilité qu’ils
soient tous en attente sur une E/S (et donc que le processeur soit inutilisé) est pn;
nous avons donc : utilisation du processeur = 1 - pn
0
10
20
30
40
50
60
70
80
90
100
012345678910
degré de multiprogrammation
Utilisation du processeur (%)
80 % d'attente sur E/S
50 % d'attente sur E/S
20 % d'attente sur E/S
Multiprogrammation avec des
partitions fixes
Il est clair (à présent) qu’il est souvent utile d’avoir + d’un processus en mémoire à la fois
Comment alors organiser la mémoire le plus efficacement possible ?
La méthode la + simple est de diviser la mémoire en n partitions (éventuellement de tailles inégales)
Chaque nouvelle tâche est placée dans la file d’attente de la plus petite partition qui peut la contenir
Partition 4
Partition 3
Partition 2
Partition 1
SE
700 K
400 K
200 K
100 K
0
Files d’entrée multiples
Trier les tâches en fonction de leurs taille dans des files multiples présente un inconvénient lorsque la file
des grandes partitions est vide et celles des petites est pleine ; une alternative consiste à utiliser 1 seule file
Partition 4
Partition 3
Partition 2
Partition 1
SE
700 K
400 K
200 K
100 K
0
File d’entrée unique
Pas intéressant d’allouer une grande partition à une petite tâche: parcourir la liste et choisir la plus grande
tâche qui peut contenir la partition
Cette stratégie désavantage les petites tâches (théoriquement il vaut mieux les traiter en priorité) ; une
solution consiste à interdire la non-sélection d’une tâche plus de kfois
Ce système à partitions fixes a été utilisé par OS/360 (IBM), il s’appelait MFT (Multiprogramming with a
Fixe
d
numbe
r
of Tasks
)
Code translatable et protection
La multiprogrammation soulève 2 problèmes majeurs : la translation et la protection
Au moment de l’édition de liens, l’éditeur de liens doit connaître l’adresse du début du programme !
Ex : appel d’un procédure à l’adresse relative 100, si le programme est chargé en partition 1, cet appel
provoque un saut à l’adresse 100 qui se trouve dans le SE ! L’adresse devrait être 100K + 100
Ce problème est est celui de la translation d’adresse
Une solution consiste à modifier les instructions du programme chargé en mémoire ; pour effectuer cette
opération l’éditeur de liens doit inclure dans le code binaire une liste de mots mémoire qui sont des
adresses pour les distinguer des codes d’opérations des constantes ou d’éléments qui ne doivent pas être
translatés
Translater les programmes au moment du chargement ne résout pas le problème de protection : comme les
programmes dans ce système utilisent des adresses mémoire absolues, on ne ne peut empêcher à un
programme de construire une instruction qui lit ou écrit n’importe quel mot mémoire !
Une autre solution aux problèmes de la translation d’adresse et de la protection est de doter la machine de
deux registres matériels spéciaux : les registres de base et limite
Quand on lance un processus, on charge dans le registre de base la limite inférieure de la partition et dans
le registre limite la longueur de la partition ; on ajoute le registre de base à chaque adresse mémoire
générée et on vérifie que cette adresse ne dépassent pas le registre de limite afin d’interdire tout accès en
dehors de la partition
L’IBM PC utilise une version simplifiée de ce mécanisme (sans registre limite)
Autre avantage du registre de base : les programmes peuvent être déplacés en mémoire après le début de
leur exécution, il suffit de modifier la valeur du registre

2
Le va-et-vient : introduction
La mémoire ne peut pas toujours contenir les
processus de tous les utilisateurs, il faut placer
quelques processus sur disque
Il faut, bien sur, ramener ce processus en mémoire
principale avant de les exécuter
Le mouvement des processus entre la mémoire
principale et le disque est appelé va-et-vient
(swapping)
Multiprogrammation
avec partitions variables (1)
On peut, en principe, utiliser les partitions fixes pour les va-et-vient (dés qu’un processus se
bloque, on le déplace sur disque et on le remplace par un autre)
En pratique, les partitions fixes ne sont pas intéressantes lorsque la mémoire est limitée (on
perd beaucoup de place à cause des programmes qui sont plus petits que les partitions
Il faut utiliser une autre solution : les partitions variables
Avec des partitions variables, le nombre et la taille des processus en mémoire varient au cours
du temps
A
SE A SE
BA
SE
BA
SE
B
C
SE
B
C
SE
B
C
DSE
C
DSE
C
D
E
La différence fondamentale avec les partitions fixes est que le nombre, la position et la taille
des partitions varient dynamiquement au fur et à mesure que les processus entrent ou sortent
de la mémoire
Plus limitée par un nombre fixe de partitions ou par la taille des partitions ; cette souplesse
accrue améliore l’usage de la mémoire mais complique son allocation et sa libération
On peut réunir les espaces inutilisées en une seule partition, on effectue alors un compactage
de la mémoire
Multiprogrammation
avec partitions variables (2)
La taille mémoire allouée aux processus mérite une attention particulière
L’allocation est simple si les processus ont une taille fixe qu’ils ne modifient jamais ; si en revanche
les processus allouent dynamiquement de la mémoire dans le tas, on a des difficultés dès qu’un
processus demande de la mémoire
S’il existe un espace adjacent au processus, ce dernier pourra occuper cet espace ; mais s’il est
entouré par deux autres processus, il faut soit le déplacer à un emplacement mémoire susceptible de
le contenir, soit déplacer un ou plusieurs processus sur disque pour créer une emplacement de taille
suffisante
Si la mémoire est saturée et si le swap ne peut plus contenir de processus, il faut tuer le processus !
La taille des processus augmente en général au cours de leur exécution ; on peut donc allouer à
chaque processus un peu plus de mémoire qu’il ne demande afin de réduire le temps système perdu
pour cette gestion ; il faut cependant recopier sur disque uniquement la mémoire réellement utilisée
par le processus
Les processus ont 2 segments qui peuvent grandir (le tas et la pile), on place la mémoire disponible
entre ces 2 segments et cet espace peut être utilisé indifféremment par un de ces segments ; si cet
espace se remplit, il faut soit déplacer le processus à un emplacement mémoire plus grand, soit le
recopier sur disque jusqu’à ce qu’il y ait de la place en mémoire principale, soit le tuer
Il existe 3 manières de mémoriser l’occupation de la mémoire : les tables de bits (bit maps), les listes
et les subdivisions (buddy)
Gestion mémoire par tables de bits
La mémoire est divisée en unités d’allocation dont la taille varie de quelques mots à
plusieurs Mo
A chaque unité, on fait correspondre un bit dans la table de bits (bit maps) qui est à 0
si l’unité est libre et à 1 si elle est occupée
La taille de l’unité d’allocation joue un rôle important : plus elle est faible, plus la table
de bits est important ; si on prend une unité d’allocation de grande taille, on réduit la
taille du bit map, mais on perd beaucoup de place mémoire chaque fois qu’un
processus n’est pas un multiple de l’unitéd’allocation
Le bit map permet donc de mémoriser l’occupation mémoire dans un espace
mémoire de taille fixe : la taille d’un bit map ne dépend pas de la taille de la mémoire
mais de la taille de l’unité d’allocation
Le seul problème survient lorsque l’on doit placer en mémoire un processus de k
unités ; le gestionnaire doit parcourir le bit map à la recherche de k zéros consécutifs ;
cette recherche est lente, ce qui fait qu’en pratique on utilise rarement les bit maps
Gestion mémoire par listes
chaînées
Une deuxième méthode pour mémoriser l’occupation mémoire consiste à gérer une liste chaînée de
segments libres et occupés
Un segment est un processus ou un espace libre entre deux processus
Chaque entrée de la liste spécifie :
– une zone libre (H [pour Hole]) ou un processus (P), – son adresse de départ
– sa longueur – un pointeur sur l’entrée suivante
Trier la liste en fonction des adresses permet de mettre à jour facilement la liste lorsqu’un processus se
termine ou est déplacé sur disque
+ieurs algos peuvent être utilisés à partir de cette liste pour allouer la mémoire aux processus
Le + simple : l’algo de la première zone libre (first fit) : rechercher le premier segment H qui peut contenir le
processus, le scinder en 2 (la première contient le processus, la seconde est H) : algo rapide puisque très
peu de recherche
Algo de la zone libre suivante (next fit) : légère variante : la recherche commence à partir de la dernière
zone libre trouvé : performance légèrement inférieure à first fit [Bays 1977]
Algo du meilleur ajustement (best fit) : on recherche dans toute la liste la plus petite zone libre qui convient,
on évite ainsi de fractionner une grande zone dont on pourrait avoir besoin ultérieurement : + lent et +
étonnant : il fait perdre plus de place mémoire que first fit (fractionnement en petite zone inutilisable) !
Algo du plus grand résidu (worst fit) : inverse on prend la plus grande zone libre : pas de bonnes perf.
Optimisations : 2 listes (pour les H et pour les P), utiliser les zones libres pour mémoriser les H : le premier
mot de chaque zone libre contient la taille de la zone et le deuxième un pointeur sur l’entrée suivante
A
l
g
o du
p
lacement ra
p
ide
(
q
uick fi
t
)
: utilise des listes sé
p
arées
p
ar les tailles de zone les
p
lus courantes
Gestion mémoire par subdivision
Les listes chaînées accélèrent l’allocation mémoire mais rendent la libération plus lente car il faut examiner
les voisins des segments libérés
L’allocation par subdivision (buddy system) est un algo de gestion qui s’appuie sur le fait que les
ordinateurs utilisent des adresses binaires de manière à accélérer la fusion des zones libres adjacentes
Le gestionnaire de la mémoire mémorise une liste de blocs libres dont les tailles sont 1, 2, 4, 8, 16, …
octets jusqu’à la taille maximale de la mémoire
Ex :
Zone
libre
Initialement 1
Demande 70 3
Demande 35 B 64 3
Demande 80 B 64 3
libération A B 64 4
Deamnde 60 B D 3
Libération B 64 D 4
Libération D 3
Libération C 1
A
256 512
512
512
256
128 1024 A
A
1024
C
C
C
C
C
128
128
128 512
128
128
Mémoire
256
512
512
512
128
128
128
L’allocation par subdivision présente un avantage par rapport aux algos qui trient en fonction de leur taille :
quand un bloc de 2k octets est libéré, le gestionnaire de la mémoire doit examiner uniquement la liste des
zones libres de 2 k octets pour voir s’il peut reconstruire un bloc plus grand
Malheureusement, il est assez inefficace en ce qui concerne l’utilisation de la mémoire, le problème vient
du fait que toutes les tailles doivent être arrondies à une puissance de 2
Un processus de 35 Ko occupe un bloc de 64Ko, les 29 Ko excédentaires sont perdus, on parle de
fragementation interne
Fragmentation externe : zone libre entre 2 segments alloués, appelé aussi phénomène de damier
(checkerboarding)
De nombreux informaticiens (Peterson et Norman, Kaufman, …) ont modifié l’allocation de subdivision pour
contourner certaines de ses limitations

3
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
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
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
Mémoire Contrôleur
de disque
CPU
MMU
Carte processeur
BUS
Le processeur envoie des adresses virtuelles au MMU
Le MMU envoie des
adresses physiques à la
mémoire
La pagination (2)
0k - 4k 2 0k - 4k
4k - 8k 1 4k - 8k
8k - 12k 6 8k - 12k
12k - 16k 0 12k - 16k
16k - 20k 4 16k - 20k
20k - 24k 3 20k - 24k
24k - 28k X 24k - 28k
28k - 32k X 28k - 32k
32k - 36k X
36k - 40k 5
40k - 44k X
44k - 48k 7 case physique
48k - 52k X
52k - 56k X
56k - 60k X page virtuelle
60k - 64k X
E
space
des
adresses
virtuelles
Adresse
mémoire
physique
Ex : ordinateur disposant de 32k de mémoire pouvant générer des adresses virtuelles
de 16 bits de 0 à 64k
On peut donc écrire des programmes de
64k, mais on ne peut les charger
entièrement en mémoire
Une image mémoire de tout le programme
est stockée sur disque de telle sorte qu’on
puisse en charger, au besoin, les
différentes parties dans la mémoire
L’espace d’adressage est divisé en petites
unités appelées pages
Les unités correspondantes de la
mémoire physique sont les cases
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
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 à 4095) 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
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

4
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
0010000000000100
01
11
21
31
4 1 Déplacement de 12 bits
5 1 recopié directement de
6 0 l'entrée à la sortie
70
80
91
10 0 Table des pages
11 1
12 0
13 0
14 0
15 0
0110000000000100
001
110
000
Adresse virtuelle
en entrée (8196)
La page virtuelle 2 sert d'index
dans la table des pages
110
010
000
101
000
111
100
011
Adresse physique
en sortie (24580)
000
000
000
000
000
000
Dans notre exemple : numéro de page
= 4 bits de poids fort et le
déplacement est stocké sur 12 bits
Les 4 bits du numéro de page
permettent d’avoir 16 pages et les 12
bits du déplacement permettent
d’adresser les 4096 octets d’une page
Le numéro de page sert d’index dans
la table des pages et donne la case
qui correspond àcette page virtuelle
Si le bit de présence est à 0, il y a
déroutement, sinon on copie le
numéro de la case dans les 3 bits de
poids fort du registre de sortie et le
déplacement fourni par l’adresse
virtuelle
Le registre de sortie contient l’adresse physique et peut être placé sur le bus de la mémoire
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 !
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 ; un 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
q
uel
q
ues nanosecondes
p
our éviter un ralentissement im
p
ortant
La table des pages (2)
La conception de la tables des pages est donc un point crucial quant à l’efficacitéde
l’ordinateur
La conception la + 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
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
La table des pages
à plusieurs niveaux
Pour éviter d’avoir des tables trop grandes
en mémoire, de nombreux ordinateurs
utilisent des tables de pages à plusieurs
niveaux
Ex : adresse virtuelle divisée en un champ
PT1 de 10 bits, un champ PT2 de 10 bits et
un champ déplacement de 12 bits (=> 220
pages de 4Ko)
Les tables des pages à plusieurs niveaux
évitent de garder en permanence toutes les
tables des pages en mémoire ; en
particulier, celles qui ne sont pas utilisées ne
devraient pas être gardées en mémoire
Ex: un prog de 12Mo divisé en 3 parties de
4Mo
0
1
2
3
4
PT1 5
6
7
.
.
.
1023
0
1
2
3
4 Table des pages
5 des 4 Mo du haut
6 de la mémoire
7
.
.
.
1023
Table des pages
de plus haut niveau
Table des pages
de second niveau
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)
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é
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
Les algorithmes de remplacement de page ont été très étudiés tant du point de vue
théorique que pratique
La bibliographie de Smith (1978) répertorie plus de 300 articles sur ce sujet, nous
étudierons quelques uns de ces algorithmes

5
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 néanmoins implanter cet algorithme en exécutant le programme sur un
simulateur qui mémorise toutes les références aux pages lors d’un première
exécution et qui utilise ces informations lors d’un deuxième exécution
On peut ainsi comparer les performances des différents algorithmes ; si par exemple,
un SE donne des résultats qui sont inférieurs de 1% à ceux de l’algo optimal, il est
inutile de rechercher un meilleur al
g
orithme
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
– Lorsqu’un défaut se produit, le SE parcourt toutes pages et les répartit en 4 catégories 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
p
as o
p
timales
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
Pour l’illustrer, considérez un épicier 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 l’épicier doit abandonner un ancien produit pour le mettre en étalage.
L’épicier 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
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 bis de chaque page seront mis à 0
et la plus ancienne page sera remplacée
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
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
AAA
A
A
A
A
A
A
A
A
A
Lorsqu’un défaut de page se produit,
la page pointée est testée.
L’action entreprise dépend du bit R :
• R=0 : retirer la page
• R=1 : mettre R à 0 et avancer pointeur
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)
LRU est théoriquement rélaisable 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épalcerau 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