Exercice Corrigé – Gestion de la mémoire – Partie 2

Voici une description concise des algorithmes d’allocation de mémoire:

1. First-fit (1ère zone libre)

• Principe: Parcourt la liste des blocs de mémoire jusqu’à trouver le premier bloc libre qui est suffisamment grand pour satisfaire la demande de mémoire.
• Avantages: Simple et rapide, car il s’arrête dès qu’il trouve un bloc adéquat.
• Inconvénients: Peut conduire à la fragmentation externe, car il utilise les premiers blocs disponibles sans tenir compte de leur taille.

2. Next-fit (Zone libre suivante)

• Principe: Semblable à First-fit, mais au lieu de recommencer la recherche depuis le début de la liste des blocs, il commence la recherche à partir de l’emplacement où le dernier bloc a été alloué.
• Avantages: Réduit le temps de recherche par rapport à First-fit, surtout si les allocations sont fréquentes.
• Inconvénients: Peut également engendrer de la fragmentation externe.

3. Best-fit (Meilleur ajustement)

• Principe: Parcourt l’ensemble des blocs de mémoire pour trouver le bloc libre le plus petit qui peut satisfaire la demande. Cela vise à minimiser l’espace perdu.
• Avantages: Réduit la fragmentation externe en utilisant les blocs les plus petits possibles.
• Inconvénients: Peut être plus lent en raison de la nécessité d’examiner tous les blocs et peut aussi créer de nombreux petits fragments inutilisés.

4. Worst-fit (Pire ajustement)

• Principe: Sélectionne le plus grand bloc libre disponible qui peut satisfaire la demande. L’idée est de laisser de grandes portions de mémoire libres pour des allocations futures.
• Avantages: Peut réduire la fragmentation en préservant des blocs de mémoire plus grands.
• Inconvénients: Souvent inefficace, car cela peut créer des fragments inutilisés et gaspiller de l’espace.

Résumé

Chaque algorithme a ses avantages et inconvénients, et le choix de l’algorithme d’allocation dépend des caractéristiques spécifiques de l’application et des exigences de performance en matière de gestion de la mémoire.

Soit p1, p2, p3 et p4 les noms des processus.

A. First-fit:

P1 >>> 100, 500, 200, 300, 600
P2 >>> 100, 288, 200, 300, 600
P3 >>> 100, 288, 200, 300, 183
       100, 116, 200, 300, 183 <<<<< dernière série de trous
P4 (426K) doit attendre

B. Best-fit:

P1 >>> 100, 500, 200, 300, 600
P2 >>> 100, 500, 200, 88, 600
P3 >>> 100, 83, 200, 88, 600
P4 >>> 100, 83, 88, 88, 600
       100, 83, 88, 88, 174 <<<<< dernière série de trous

C. Worst-fit:

P1 >>> 100, 500, 200, 300, 600
P2 >>> 100, 500, 200, 300, 388
P3 >>> 100, 83, 200, 300, 388
       100, 83, 200, 300, 276 <<<<< dernière série de trous
P4 (426K) doit attendre

Best-fit (Meilleur ajustement) s'avère être la meilleure solution car il n'y a pas de processus d'attente.

A) Soit (m) le nombre de bits dans l'adresse logique

m = ???

Taille de l'espace d'adressage logique = 2m = Nombre de pages × taille de la page
                                         2m = 64 × 1024
                                         2m = 26 × 210
                                         2m = 216 => m = 16 bit

=> Nombre de bits requis dans l'adresse logique = m = 16 bit

B) Soit (x) le nombre de bits dans l'adresse physique

x = ???

Taille de l'espace d'adressage physique = 2x
Taille de l'espace d'adressage physique = Nombre de cadres × taille de la cadres
(taille du cadre = taille de la page)
Taille de l'espace d'adressage physique = 32 × 1024
                                     2x = 25 × 210
                                     2x = 215 => x = 15 bit

=> Nombre de bits requis dans l'adresse physique = x = 15 bit

A) Soit (m) le nombre de bits dans l'adresse logique

m = ???

Taille de l'espace d'adressage logique = 2m = Nombre de pages × taille de la page
                                         2m = 32 × 1024
                                         2m = 25 × 210
                                         2m = 215 => m = 15 bit

=> Nombre de bits requis dans l'adresse logique = m = 15 bit

B) Soit (x) le nombre de bits dans l'adresse physique

x = ???

Taille de l'espace d'adressage physique = 2x
Taille de l'espace d'adressage physique = Nombre de cadres × taille de la cadres
(taille du cadre = taille de la page)
Taille de l'espace d'adressage physique = 16 × 1024
                                     2x = 24 × 210
                                     2x = 214 => m = 14 bit

=> Nombre de bits requis dans l'adresse physique = x = 14 bit

Si la taille d'une page est 2ⁿ et que 2¹⁰ = 1024 octets, alors:

Taille de la Page = 2n = 1024 octets = 210 octets

Explication:

• n est l'exposant qui représente le nombre de bits nécessaires pour adresser les mots dans la page.
• Dans ce cas, n=10 signifie qu'il faut 10 bits pour adresser chaque octet au sein de la page de 1024 octets.

Etapes de la solution:

• 1. Convertir l'adresse logique: Décimale -> Binaire
• 2. Diviser l'adresse binaire en 2 parties (numéro de la page , Offset), offset: n chiffres
• 3. Conversion de l'offset et le numéro de la page: Binaire -> Décimale

+---------------+----------------+------------+--------------+---------+--------+
|Adresse logique| Adresse logique|  N° page   |    Offset    | N° page | Offset |
|  (décimale)   |    (binaire)   |(6bits)(bin)| (10bits)(bin)|  (déc)  | (déc)  |
+---------------+----------------+------------+--------------+---------+--------+
| 2375          |0000100101000111| 000010     | 01 0100 0111 | 2       | 327    |
+---------------+----------------+------------+--------------+---------+--------+
| 19366         |0100101110100110| 010010     | 11 1010 0110 | 18      | 934    |
+---------------+----------------+------------+--------------+---------+--------+
| 30000         |0111010100110000| 011101     | 01 0011 0000 | 29      | 304    |
+---------------+----------------+------------+--------------+---------+--------+
| 256           |0000000100000000| 000000     | 01 0000 0000 | 0       | 256    |
+---------------+----------------+------------+--------------+---------+--------+
| 16385         |0100000000000001| 010000     | 00 0000 0001 | 16      | 1      |
+---------------+----------------+------------+--------------+---------+--------+

La mémoire virtuelle est une technique qui permet à un système d'exploitation de gérer la mémoire de manière plus efficace en créant une abstraction de la mémoire physique. Voici les points clés:

• Espace d'adressage distinct: Chaque processus dispose de son propre espace d'adressage logique, isolé des autres processus. Cela permet une exécution sécurisée et stable des applications.
• Abstraction de la mémoire physique: La mémoire virtuelle ne correspond pas nécessairement à la mémoire physique disponible. Elle utilise des adresses logiques qui sont traduites en adresses physiques via un mécanisme de pagination ou de segmentation.
• Indépendance de la technologie: L'espace d'adressage est indépendant des détails matériels et des technologies de stockage sous-jacentes. Cela permet une plus grande flexibilité dans la gestion de la mémoire.
• Gestion des ressources: La mémoire virtuelle permet d'utiliser des techniques telles que le swapping, où des pages de mémoire peuvent être déplacées entre la mémoire physique et le disque dur, ce qui permet de gérer des applications plus grandes que la mémoire physique disponible.

En résumé, la mémoire virtuelle permet une gestion efficace des ressources mémoire, améliore la sécurité et facilite l'exécution de programmes en utilisant un espace d'adressage abstrait et isolé.

La mémoire virtuelle améliore l'utilisation de la mémoire principale de plusieurs façons:

• Non-contiguïté des processus: Les processus peuvent être chargés à des emplacements non contigus, permettant une allocation flexible.
• Réduction de la fragmentation externe: La mémoire physique peut être utilisée plus efficacement, car les pages peuvent être placées où de l'espace est disponible, minimisant le gaspillage.
• Pagination: La division en pages facilite l'ajustement entre les besoins des processus et l'espace disponible.
• Swapping: Les pages non utilisées peuvent être transférées sur le disque, libérant de l'espace en mémoire principale.
• Isolation: Chaque processus a son propre espace d'adressage, ce qui évite les conflits et améliore la sécurité.

En résumé, la mémoire virtuelle optimise l'utilisation de la mémoire principale en rendant l'allocation plus flexible et efficace.

Le mappage est le processus de translation des adresses logiques (virtuelles) d'un processus en adresses physiques dans la mémoire principale.

• Translation d'adresses: Utilise une table de pages pour associer chaque page logique à une page physique.
• Gestion dynamique: Permet de déplacer des pages entre mémoire physique et stockage secondaire.
• Isolation: Assure que chaque processus fonctionne dans son propre espace d'adressage, empêchant les interférences.

En résumé, le mappage relie la mémoire virtuelle à la mémoire physique, optimisant la gestion et la sécurité de la mémoire.

L'unité de gestion de la mémoire (MMU - Memory Management Unit) est le composant du processeur chargé de mettre en œuvre la mémoire virtuelle.

• Fonction: La MMU traduit les adresses logiques (virtuelles) en adresses physiques en utilisant des tables de pages.
• Gestion des accès: Elle gère également les protections et les permissions d'accès à la mémoire.

En résumé, la MMU est essentielle pour la gestion efficace de la mémoire virtuelle.

Pagination est un concept clé de la mémoire virtuelle.

• Principe: Il divise la mémoire en unités fixes appelées pages (pour la mémoire virtuelle) et cadres (pour la mémoire physique).
• Avantages: Cela permet une allocation dynamique de la mémoire, réduit la fragmentation externe et facilite le partage de la mémoire entre processus.

En résumé, la pagination est une méthode essentielle pour gérer la mémoire virtuelle de manière efficace.

Fragmentation interne est le type de fragmentation qui se produit avec le concept de pagination.

• Définition: Elle survient lorsque la taille d'une page est supérieure à la quantité de mémoire réellement utilisée par un processus.
• Cause: Cela peut se produire uniquement dans la dernière page de chaque processus, où l'espace non utilisé dans cette page représente la fragmentation.

En résumé, la fragmentation interne est une conséquence de la pagination, résultant d'un espace inutilisé dans les pages.