Memoire 2

Gestion de la mémoire centrale
Allocation de la mémoire physique
Joëlle Delacroix NSY103 1

Fonction de mémorisation
CPU Mémoire centrale
RAD
RDO
Bus données
Bus adresses
Bus commandes
) ensemble linéaire de mots d'adresses contigues

Monoprogrammation
0 P1 : 100 ms calcul / 100 ms E/S

SYSTEME 50 % d'inactivité du processeur
D'EXPLOITATION
N
P1
PROGRAMME
UTILISATEUR
P1 CPU
DMA

Multiprogrammation : cas idéal
0 P1 : 100 ms calcul / 100 ms E/S

SYSTEME P2 : 100 ms calcul / 100 ms E/S
0 % d'inactivité du processeur
N D'EXPLOITATION
PROGRAMME P1
UTILISATEUR
P1
P2
PROGRAMME
UTILISATEUR CPU
P2
DMA
Multiprogrammation et gestion mémoire
• Trois problèmes à résoudre vis-à-vis de la mémoire :
– Définir un espace d'adressage indépendant pour chaque

processus
– Protéger les espaces d'adressages des processus entre

eux
– Allouer de la mémoire physique à chaque espace

d'adressage

Multiprogrammation et gestion mémoire
programme
ensemble insécable de mots contigus
ensemble sécable de mots contigus
espace d'adressage linéaire
allocation en partitions
fixes ou variables espace d'adressage paginé
espace d'adressage segmenté

PAGINATION
• L‘espace d’adressage linéaire du programme est coupé en

portions de taille fixe et égale à l'unité d'allocation de la
mémoire centrale : les pages.
• Chaque adresse devient une adresse paginée formée

d’un couple (numéro de page, déplacement dans la page)

La pagination
0 0
Page 1 512 octets
Page 2
1048 1048 (Page 3, dep 24)

Page 3
Load R1 D 1048 Load R1 D (Page 3, dep 24)

Page 4
Espace d'adressage Espace d'adressage

du programme du programme
LINEAIRE PAGINE
Adresse linéaire Adresse paginée (logique)

(déplacement depuis 0) (n° de page, déplacement dans la page depuis 0)

La pagination
Mémoire
Case1
Page 1 Case 2
Page 1
Page 3 Case 3
Page 2
Page 4
Case 4
Page 3
Case 5
Espace d'adressage Page 2 Case 6

du programme
Page 4 Case 7

La pagination
• L'espace d'adressage du programme est découpé en

morceaux linéaires de même taille : la page.
• L'espace de la mémoire physique est lui-même découpé

en morceaux linéaires de même taille : la case
• La taille d'une case est égale à la taille d'une page
• Charger un programme en mémoire centrale consiste à

placer les pages dans n'importe quelle case disponible.

La mémoire paginée
adr De 512 octets

PAGE à
8192 octets
adresse
physique
Adresse paginée
<n°page; déplacement>
) Il faut convertir l'adresse paginée en son équivalent adresse physique

Adresse physique = adresse implantation case contenant la page (adr)
+ deplacement
¾ Table des pages

Mémoire
Table des pages Case1

Page 1 Numéro Numéro
page case Page 1 Case 2
Page 2 1 2 Page 3 Case 3
2 6
Case 4
Page 3
3 3 Case 5
Page 4 4 7
Page 2 Case 6
Espace d'adressage Page 4 Case 7

du programme
Implémentation de la table des pages
• Un ensemble de registres matériels

– commuter de processus = charger tous les registres avec les
adresses des pages du processus
– la table des pages ne peut pas être très grande (256 entrées)
1. Processus A actif 2. Processus A préempté

Processus B élu
Page 1 PA
CO PA
Page 2 PA Page 1 PB
PCB PA PCB PB
PSW PA
Page 3 PA Page 2 PB
Page 3 PB CO PB
Page 4 PA
PSW PB
Registres MMU
Joëlle Delacroix NSY103 Registres MMU 13
• En mémoire centrale, repérée par un registre PTBR (page

table base register)
– commuter de processus = charger le registre PTBR avec l'adresse
de la table des pages du processus
– pas de limite de taille à la table des pages
1. Processus A actif 2. Processus A préempté Table des pages

Processus B élu
CO PA A B
PSW PA
PCB PA
CO PB PCB PB
A PTBR PSW PB
B PTBR
Mémoire
Adresse logique
p d
Registre adresse Adresse phy sique d

Table des pages
adresse table +
+
adr page
En MC
Matériel
Table des pages

• temps d'accès à un emplacement mémoire d'un programme :
deux accès mémoire
Adresse logique
p d
Adresse phy sique
adresse table +
+
adr page
Table des pages

• Un cache associatif contenant les derniers couples <page,
case> accédés est placé en amont de la table des pages
Adresse logique
p d
Adresse phy sique

trouvé
+
adresse table
no
n tro
uv
é
+
<p, adr page>
adr page
Table des pages

Pagination - Segmentation
données
Sqrt Segment 1
Programme
principal
Segment 4
Pile Segment 2
Segment 3
Vue Utilisateur
Espace d'adressage
du programme Espace d'adressage
Ensemble de pages du programme
Ensemble de segments
La mémoire segmentée
• Le programme est divisé en segments par le compilateur, un segment

étant un espace d'adressage linéaire formé d'adresses contigues.
• Un segment correspond à une partie logique du programme : segment

de code, segment de données, segment de pile
S3
Espace
Espace 100 K d'adressage
d'adressage S1 segmenté
linéaire 180K
50 K
30 K
S2
S3 Espace
0 d'adressage
Espace 100 K
d'adressage S1 segmenté
180K 50 K
linéaire 0
Adresse du mot avant chargement

Déplacement depuis 0 S2
Adresse du mot avant chargement

Adresse du mot après chargement
N° segment, Déplacement depuis 0
Adresse d'implantation + Déplacement
Adresse du mot après chargement
Adresse d'implantation du segment
+ Déplacement
SEGMENT
adresse
physique
<n°segment; deplacement>
) Il faut convertir l'adresse segmentée en son équivalent

adresse physique
Adresse physique = adresse implantation segment + deplacement
¾ Table des segments

La mémoire segmentée Mémoire
Table des segments

50K
Segment 1 Segment 1
20K Numéro Position
1 50 K
Segment 2
25K 95K
2 195 K Segment 3
Segment 3 95 K
3
15K 150 K
Segment 4
4 150 K
Segment 4
10K
195 K
Espace d'adressage Segment 2
du programme
Mémoire
s d <
Registre adresse
Table des Segments
+
LT adresse table
< +
oui
taille adr debut
Table des segments

La segmentation
• Allouer un segment S de taille Taille(S) :

ª trouver une zone libre telle que
Taille (Zone Libre) >= Taille (S)
ªFisrt Fit : la première zone qui convient

ªBest Fit : celle générant le moins de perte
• Allocations et désallocations successives des segments

créent également un problème de fragmentation
) Compacter la mémoire centrale : cher.

) combiner segmentation et pagination : paginer les segments

Allocation First Fit
0 0
n Système Système
n
Zone libre 60K Zone libre 60K
Segment P1 80K Segment P1
Zone libre 120K Segment P3
Segment P3 40K
Segment P2 Segment P2

Zone libre Zone libre

150K 150K

Allocation Best Fit
0 0
n Système Système
n
Segment P1 80K Segment P1
Zone libre 120K Zone libre
Segment P3 40K
Segment P3
Zone libre 100K 20K

150K 150K

Compactage de la mémoire
0 0
Système
n n Système
Zone libre 60 K Segment P1
Segment P1 180K
Segment P3
Zone libre 120 K
Segment P2
Segment P4
Segment P3
Segment P1
Segment P2
20K
Segment P1
350 K
150K
Fragmentation
Compactage de la mémoire
• Allocations et désallocations successives des programmes

créent des trous (zones libres de taille insuffisante) en
mémoire centrale : fragmentation
• Le compactage consiste à déplacer les programmes en

mémoire centrale de manière à ne créer qu'une seule et
unique zone libre.
¾ Combiner pagination et segmentation

La mémoire segmentée paginée
• L’espace d’adressage du processus est segmenté. Chaque

segment est à son tour paginé. Les pages résultantes sont
allouées dans les cases de la mémoire centrale.
0
Espace S1
d'adressage 120 K
200K 0
linéaire
d
S2 (S2, d)
pages d’ (S2, P1, d’)

P1
P1
La mémoire segmentée paginée
Mémoire
d
oui
s d < p d'
P1 S
Registre adresse
Table des Segments + c +
LT adresse table
P3 S
< +
oui Adresse
S taille table P2 S
des pages
Table des segments

Gestion mémoire
• L'allocation en partitions fixes ou variables considère le programme
comme un ensemble d'adresses insécables. Ce type d'allocation pose
un problème de fragmentation et nécessite des opérations de
compactage de la mémoire centrale
• La pagination découpe l'espace d'adressage du programme en pages

et la mémoire physique en cases de même taille. Une adresse générée
par le processeur est de la forme <n°page, déplacement dans la page>.
La table des pages du processus permet de traduire l'adresse paginée
en adresse physique
• La segmentation découpe l'espace d'adressage du programme en

segments correspondant à des morceaux logiques du programme. Une
adresse générée par le processeur est de la forme <n°segment,
déplacement dans le segment>. La table des segments du processus
permet de traduire l'adresse segmentée en adresse physique
• Segmentation et pagination sont très souvent associées.

Mémoire Virtuelle

Mémoire virtuelle
Mémoire physique
Page 1 Page 3-1 Case 1

Page 4 Page 2
Page 1
Programme 1 Page 2 Page 3-2 Case 3

Page 3
Page 4 Page 2 Programme 2
Page 2-2 Case 5
Page 3
Programme 3 Page 2-1 Case 6
Espaces d'adressage Page 4-1 Case 7

des programmes
Mémoire virtuelle
• La capacité de la mémoire centrale est trop petite pour charger

l'ensemble des pages des programmes utilisateurs.
) Ne charger que les pages utiles à un instant.

Mémoire physique
Page 1
Page 3-3 Case 1
Page 4 Page 2
Page 1
Page 3
Page 4-1 Case 7

Bit de validation
• Ne charger que les pages utiles à un instant
) il faut pouvoir tester la présence d'une page en mémoire centrale
V N° de case physique
• Bit validation à vrai si la page

est présente en mémoire centrale

Bit de validation
V 2 I - V 5
V 4 I - V 6
I - V 3 V 1
V 7 Processus 2 I -
Processus 1 Processus 3 Mémoire physique

Page 1
Page 3-3 Case 1
Page 4 Page 2
Page 1
Page 3
Page 4-1 Case 7

Bit de validation et défaut de page
V 2 I - V 5
V 4 I - V 6
I - V 3 V 1
V 7 Processus 2 I -
Processus 1 Processus 3 Mémoire physique

Page 4 Page 2
Page 1-1 Case 2
Page 3
Page 1
Programme 1
Page 3
Processus 2 : accès à la page 2
DEFAUT DE PAGE
Page 2-3 Case 6
Programme 3
Page 4-1 Case 7

Bit de validation et défaut de page
• Ne charger que les pages utiles à un instant
) il faut pouvoir tester la présence d'une page en mémoire centrale :

) rôle du bit de validation
) si un processus cherche à accéder à une page non présente en mémoire

centrale, il se produit un déroutement de défaut de page
• le système d'exploitation lance une entrée/sortie disque

pour charger la page en mémoire dans une case libre

Défaut de page Mémoire
Adresse logique
p d
Registre adresse 1. Déroutement

Table des pages E/S disque
adresse table
I -
Table des pages

Défaut de page Mémoire
Adresse logique
p 4. Reprise
d
instruction
Registre adresse
Table des pages
adresse table
case libre
2 Chargement de la page
+
I 5
3. Mise à jour table des pages
Table des pages

Chargement de page
• Lors d'un défaut de page, la page manquante est chargée dans une
case libre
) la totalité des cases de la mémoire centrale peuvent être occupées

) il faut libérer une case globalement (parmi l'ensemble des cases) ou localement
(parmi les cases occupées par les pages du processus en défaut)
• le système d'exploitation utilise un algorithme pour choisir

une case à libérer
- FIFO (First In, First out)
- LRU (Least Recently Used)

Algorithmes de remplacement de page
• FIFO : la page la plus anciennement chargée est la page remplacée
Chaine de référence
7 0 1 2 0 3 0 4 2 3 0
7 7 7 2 2 2 2 4 4 4 0
0 0 0 0 3 3 3 2 2 2
1 1 1 1 0 0 0 3 3
D D D D D D D D D D

Algorithmes de remplacement de page
• LRU : la page la moins récemment accédée est la page remplacée
Chaine de référence
7 0 1 2 0 3 0 4 2 3 0
7 7 7 2 2 2 2 4 4 4 0
0 0 0 0 0 0 0 0 3 3
1 1 1 3 3 3 2 2 2
D D D D D D D D D

Algorithme de remplacement de page
A M V N° de case physique
• Bit modification à vrai si la page

a été modifiée en mémoire centrale
• Champ Accès :
FIFO : date de chargement
LRU : date de dernier accès

Algorithme de remplacement de page
A M V N° de case physique
• Bit modification à vrai si la page

a été modifiée en mémoire centrale
(Page à recopier sur disque si M est vrai)
• Champ Accès :
FIFO : date de chargement
LRU : date de dernier accès

Libération de page Mémoire
Adresse logique
p 4. Reprise
d
instruction
Registre adresse
Recherche page à libérer

Table des pages
Ec
rit
ur
adresse table
e
de
la
pa
ge
+
I
M
2. Chargement de la page
Table des pages 3. Mise à jour table des pages

sous Linux

La mémoire vue par Linux
• L'espace d'adressage d'un processus est composé de régions

– une région de code
– une région des variables initialisées
– une région des variables non initialisées
– une région pour les codes et données des bibliothèques
– une région pour la pile
• Une région est une zone contiguë de l'espace d'adressage traitée

comme un objet pouvant être partagé et protégé. Elle est caractérisée
par
– ses adresses de début et de fin
– les droits d'accès qui lui sont associés
– l'objet qui lui est associé
• Une région est divisée en pages (4 Ko)

La table des pages
• Une entrée de table des pages contient :
Present Accessed Dirty Read/write Case
• Chaque case est décrit par un descripteur :
Adresses case libre précédente et suivante
Nombre de processus se partageant la page
État de la page (verrouillée, accédée, …)
Champ dirty ( page modifiée)
Champ age

La table des pages
• Les champs Accessed et Age sont utilisés par le processus "Dérobeur

de Pages" (thread noyau kswapd) pour choisir des victimes
– le dérobeur de pages est réveillé toutes les 10 secondes
– le dérobeur de pages libère des pages si le nombre de cases libres

est tombé en dessous d'un seuil minimal
– Une page est victime si elle a atteint un age donné (paramètre

système) sans être référencée.

La table des pages
A chaque référence par le processus, l'age de la page devient égal à 0 et le bit

accessed est mis à vrai
A chacun de ses passages, le dérobeur de pages :

- met à faux le bit accessed si il est à vrai
- incrémente l'age de la page
En mémoire Accessed Age
Une page est victime si Accès P v 0
- le bit accessed est faux Accès D F 1
- l'age limite est atteint (ici par exemple 3) Accès D F 2
Accès P v 0
Accès D F 1
Accès P
v 0
Accès D
F 1
Accès D
F 2
Accès D
Transférée F 3

Régions de mémoire partagée
(Shared Memory)

Shared memory Régions en MC
privé
Processus A
Processus B privé
• Région de mémoire pouvant être partagée entre plusieurs processus

• Un processus doit attacher le région à son espace d'adressage avant
de pouvoir l'utiliser
• Outil IPC repéré par une clé unique
• L'accès aux données présentes dans la région peut requérir une
synchronisation (outil sémaphore)

Shared memory
• Création ou accès à une région de mémoire partagée
int shmget (key_t cle, int taille, int option)
Identification
Constantes IPC_CREAT,
Interne de la région Identification Taille de la région
externe de la région en octet IPC_EXCL
et droits d'accès
• Attachement d'une région de mémoire partagée
void *shmat (int shmid, const void *shmadd, int option)
Adresse effective Adresse de

de la région Identification la région
Interne de la région (0 ou valeur)
• Détachement d'une région de mémoire partagée

void *shmdt (void *shmadd)
/******************************************************************/
/* processus créateur du segment et écrivain */
/******************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define CLE 256
main()
{
int shmid;
char *mem ;
/* création du segment de mémoire partagée avec la clé CLE */

shmid=shmget((key_t)CLE,1000,0750 |IPC_CREAT | IPC_EXCL);
/* attachement */
if((mem=shmat(shmid,NULL,0))==(char *)-1)
{
perror("shmat");
exit(2);
}
/* écriture dans le segment */

strcpy(mem,"voici une écriture dans le segment");
exit(0);
}

/******************************************************************/
/* processus destructeur du segment et lecteur */
/******************************************************************/
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#define CLE 256
main()
{
/* récupération du segment de mémoire */
shmid=shmget((key_t)CLE,0,0);
/* attachement */
mem=shmat(shmid,NULL,0);
/* lecture dans le segment */

printf("lu: %s\n",mem);
/* détachement du processus */
shmdt(mem);
/* destruction du segment */
shmctl(shmid,IPC_RMID,NULL);
exit(0)
}

Memoire 2

Transféré par

Informations du document

Titre original

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

Memoire 2

Transféré par

Droits d'auteur :

Formats disponibles

Gestion de la mémoire centrale

Allocation de la mémoire physique

Joëlle Delacroix NSY103 1

) ensemble linéaire de mots d'adresses contigues

0 P1 : 100 ms calcul / 100 ms E/S

Joëlle Delacroix NSY103 3

0 P1 : 100 ms calcul / 100 ms E/S

• Trois problèmes à résoudre vis-à-vis de la mémoire :

– Définir un espace d'adressage indépendant pour chaque

– Protéger les espaces d'adressages des processus entre

– Allouer de la mémoire physique à chaque espace

Joëlle Delacroix NSY103 5

ensemble insécable de mots contigus

ensemble sécable de mots contigus

espace d'adressage linéaire

Joëlle Delacroix NSY103 6

• L‘espace d’adressage linéaire du programme est coupé en

• Chaque adresse devient une adresse paginée formée

Joëlle Delacroix NSY103 7

1048 1048 (Page 3, dep 24)

Load R1 D 1048 Load R1 D (Page 3, dep 24)

Espace d'adressage Espace d'adressage

Adresse linéaire Adresse paginée (logique)

Joëlle Delacroix NSY103 8

Espace d'adressage Page 2 Case 6

Joëlle Delacroix NSY103 9

• L'espace d'adressage du programme est découpé en

• L'espace de la mémoire physique est lui-même découpé

• La taille d'une case est égale à la taille d'une page

• Charger un programme en mémoire centrale consiste à

Joëlle Delacroix NSY103 10

adr De 512 octets

) Il faut convertir l'adresse paginée en son équivalent adresse physique

¾ Table des pages

Table des pages Case1

Page 2 1 2 Page 3 Case 3

Espace d'adressage Page 4 Case 7

• Un ensemble de registres matériels

1. Processus A actif 2. Processus A préempté

• En mémoire centrale, repérée par un registre PTBR (page

1. Processus A actif 2. Processus A préempté Table des pages

Registre adresse Adresse phy sique d

Table des pages

Adresse phy sique

Table des pages

Joëlle Delacroix NSY103 16

Adresse phy sique

Table des pages

Joëlle Delacroix NSY103 17

• Le programme est divisé en segments par le compilateur, un segment

• Un segment correspond à une partie logique du programme : segment

Adresse du mot avant chargement

Adresse du mot avant chargement

) Il faut convertir l'adresse segmentée en son équivalent

¾ Table des segments

Table des segments

Table des segments

• Allouer un segment S de taille Taille(S) :

ªFisrt Fit : la première zone qui convient

• Allocations et désallocations successives des segments

) Compacter la mémoire centrale : cher.

Joëlle Delacroix NSY103 24

Zone libre 100K Zone libre 100K