Qu'est-ce que Memory Management ?

1. Anatomie de la mémoire : Distinction entre la pile (Stack) et le tas (Heap)

Lorsqu'un programme est exécuté, le système d'exploitation alloue un espace d'adressage virtuel dédié à ce processus. Les deux composants les plus critiques de cet espace sont la pile (Stack) et le tas (Heap) :

+------------------------------------+ Yüksek Bellek Adresleri (0xFFFFFFFF)
|           İşletim Sistemi / Kernel |
+------------------------------------+
|  STACK (Aşağıya doğru büyür ↓)     | <-- Yerel değişkenler, fonksiyon çerçeveleri
|                 ↓                  |
|                                    |
|                 ↑                  |
|  HEAP (Yukarıya doğru büyür ↑)     | <-- Dinamik nesneler (malloc, new)
+------------------------------------+
|  BSS (İlklendirilmemiş Global)     |
+------------------------------------+
|  DATA (İlklendirilmiş Statik Veri) |
+------------------------------------+
|  TEXT (Makine Kodu / Talimatlar)   |
+------------------------------------+ Düşük Bellek Adresleri (0x00000000)

• Pile (Stack) : Gérée automatiquement par l'architecture du CPU (LIFO). Extrêmement rapide (seul le registre du pointeur de pile est décalé). Cependant, sa taille est fixe (1 Mo - 8 Mo) et elle provoque un Stack Overflow en cas de récursion infinie.
• Tas (Heap) : Géré par le développeur ou l'environnement d'exécution (Runtime) du langage. Alloué aux objets dynamiques ; peut s'étendre jusqu'à la limite de la RAM physique et de la mémoire d'échange (swap). S'il n'est pas nettoyé, il provoque des fuites de mémoire (Memory Leak) et une fragmentation.

2. Trois paradigmes fondamentaux de gestion de la mémoire

• Gestion manuelle de la mémoire (C, C++) : Le développeur gère lui-même la mémoire via malloc() et free(). Cela offre une vitesse maximale et une latence nulle, mais comporte des risques de fuites, de pointeurs pendants (dangling pointers) et d'utilisation après libération (Use-After-Free), qui sont à l'origine de plus de 70 % des failles de sécurité dans le monde du logiciel.
• Ramassage automatique des déchets (Garbage Collection - Java, Go, Python, JS) : Le programmeur n'effectue pas de suppression ; le moteur de GC fonctionnant en arrière-plan nettoie les objets orphelins inaccessibles depuis les références racines à l'aide d'algorithmes de marquage et balayage (Mark-and-Sweep) ou de comptage de références (Reference Counting). Cependant, les analyses périodiques peuvent entraîner des micro-pauses (Stop-The-World).
• Modèle de propriété et d'emprunt (Ownership & Borrowing - Rust) : Le compilateur Rust vérifie à la compilation que chaque bloc mémoire possède un propriétaire unique. Sans recours à un ramasse-miettes, il garantit une sécurité mémoire (Memory Safety) à 100 % avec la vitesse du C.

3. Mémoire au niveau du système d'exploitation : Mémoire virtuelle et OOM Killer

Les systèmes d'exploitation modernes utilisent une architecture de mémoire virtuelle et de pagination pour empêcher les programmes de lire la mémoire les uns des autres. L'unité de gestion de la mémoire (MMU) du processeur traduit les adresses virtuelles en adresses physiques matérielles à l'aide du cache TLB. Lorsque la RAM physique et le swap sont totalement épuisés, le mécanisme OOM Killer (Out of Memory Killer) du noyau Linux met fin au processus le plus agressif avec un signal SIGKILL afin de sauver le système.

Questions et réponses

Termes liés