21 - Glossaire
Ce que tu vas apprendre
- Les définitions de tous les termes mémoire utilises dans cette serie
- Ou trouver chaque concept dans les articles précédents
Prerequisites
Aucun. Ce glossaire est fait pour etre consulte a tout moment.
Tu as lu 20 articles. Tu as vu passer des dizaines de termes. Certains reviennent souvent, d'autres une seule fois. Ce glossaire rassemble tout au meme endroit. Chaque entree a une définition courte et un lien vers l'article qui en parle le plus.
Je l'ai écrit parce que j'aurais aime l'avoir quand je debuggais ma première fuite mémoire. Ouvrir 5 onglets de documentation pour retrouver ce qu'est un "retainer" en pleine session de profiling, c'est penible.
Sur paltemps.fr, je garde un fichier similaire dans le wiki interne du projet. Ca fait gagner du temps a toute l'équipe.
A
AbortController -- Objet qui permet d'annuler des opérations asynchrones (fetch, streams). En React, tu l'utilises dans le cleanup de useEffect pour annuler les requêtes en cours quand le composant se demonte. Voir Fuites mémoire en React.
Allocation -- L'acte de reserver de la mémoire pour stocker une valeur. En JavaScript, chaque new Object(), chaque literal {}, chaque string créé une allocation sur le heap. Voir Cycle de vie de la mémoire.
ArrayBuffer -- Un bloc de mémoire brute de taille fixe. C'est le conteneur sous-jacent des TypedArrays. Tu ne peux pas lire ou écrire directement dedans : tu dois utiliser une "vue" comme Uint8Array ou Float64Array. Voir Arrays et typed arrays.
B
Backpressure -- Mecanisme qui ralentit un producteur quand le consommateur ne suit pas. Sans backpressure, les donnees s'accumulent en mémoire. Les Node.js Streams gerent ca nativement. Voir Streams et backpressure.
Borrowing -- Concept Rust. Emprunter une référencé a une valeur sans en prendre la propriété. Le borrow checker du compilateur garantit qu'il n'y a pas de références pendantes. Voir Comparaison avec d'autres langages.
C
Call stack (pile d'appels) -- La zone mémoire qui stocke les frames d'exécution de fonctions. Chaque appel de fonction empile un frame, chaque retour le depile. Taille limitee (environ 1 Mo). Un dépassement cause un "stack overflow". Voir Stack vs Heap.
Closure -- Une fonction qui capture les variables de son scope parent. Le problème : si la closure survit longtemps, elle retient en mémoire tout ce qu'elle a capture, meme si tu n'utilises qu'une seule variable. Voir Closures et mémoire.
Compaction -- Phase du GC qui deplace les objets survivants pour eliminer la fragmentation. V8 fait du compaction pendant le Major GC. Ca permet d'avoir de la mémoire contigue pour les futures allocations. Voir V8 en profondeur.
Concurrent GC -- Un garbage collector qui trace les objets pendant que le programme tourne, sans l'arrêter (ou presque). Go et ZGC (Java) sont des exemples. V8 fait du marking concurrent mais pas du compaction concurrent. Voir Comparaison avec d'autres langages.
D
Detached DOM -- Un noeud DOM qui a ete retire du document mais qui est encore référencé par du JavaScript. C'est une fuite classique : le DOM est invisible a l'ecran mais toujours en mémoire. Voir Les 6 fuites classiques.
E
Event emitter -- Pattern Node.js pour la communication par événements. Chaque listener ajoute retient une closure. Oublier de retirer les listeners cause des fuites. Node.js leve un warning a 11 listeners par défaut. Voir Serveurs Node.js et mémoire.
F
FinalizationRegistry -- API JavaScript qui permet d'enregistrer un callback qui sera appele quand un objet est collecte par le GC. Utile pour libérer des ressources externes (fichiers, handles). Le timing n'est pas garanti. Voir FinalizationRegistry.
Flyweight -- Pattern de conception qui partage les donnees communes entre de nombreux objets au lieu de les dupliquer. Reduit la mémoire quand beaucoup d'objets ont des propriétés identiques. Voir Optimisations mémoire.
Fragmentation -- L'état du heap quand les objets vivants et les trous libres sont melanges. Ca empeche d'allouer de gros blocs meme si la mémoire totale libre suffit. Le compaction resout ce problème. Voir V8 en profondeur.
G
GC root -- Le point de depart du garbage collector pour tracer les objets accessibles. Les GC roots incluent les variables globales, la stack, et les objets natifs du runtime. Tout objet non atteignable depuis un GC root est collecte. Voir Le garbage collector.
Generational GC -- Stratégie qui séparé les objets par age. L'hypothese generationnelle dit que la plupart des objets meurent jeunes. Le new space est collecte souvent et vite, le old space rarement. Voir V8 en profondeur.
H
Heap -- La zone mémoire ou vivent les objets JavaScript. Contrairement a la stack (LIFO, taille fixe), le heap est dynamique et peut grandir. C'est la que le GC opéré. Voir Stack vs Heap.
Heap snapshot -- Une photo de tout le heap a un instant donne. Contient chaque objet, sa taille, et ses références. Tu peux les prendre dans Chrome DevTools ou avec --heapsnapshot-signal en Node.js. Voir Chrome DevTools.
Hidden class -- Structure interne de V8 qui decrit la "forme" d'un objet (quelles propriétés, dans quel ordre). Les objets de meme forme partagent la meme hidden class, ce qui permet des acces rapides. Voir Object shapes et hidden classes.
L
LRU cache -- Cache qui evince les éléments les Moins Recemment Utilises quand il atteint sa taille maximale. Contrôle la mémoire contrairement a un Map qui grandit indefiniment. Voir Serveurs Node.js et mémoire.
M
Major GC (Mark-Sweep-Compact) -- Le ramassage de tout le old space. Plus lent que le Minor GC. V8 le déclenché quand le old space est trop plein. Les pauses peuvent atteindre 50 a 200ms. Voir V8 en profondeur.
Mark-and-sweep -- L'algorithme de base du GC. Phase 1 : marquer tous les objets accessibles depuis les GC roots. Phase 2 : supprimer (sweep) tous les objets non marques. Voir Le garbage collector.
memlab -- Outil de Meta pour détecter automatiquement les fuites mémoire dans les applications web. Prend 3 snapshots (avant, pendant, apres) et identifié les objets qui fuitent. Voir Tester la mémoire.
Minor GC (Scavenge) -- Le ramassage du new space. Rapide (1 a 5ms) parce que le new space est petit et que la plupart des objets sont deja morts. Voir V8 en profondeur.
N
New space -- La zone du heap V8 ou les objets sont alloues initialement. Petite (quelques Mo), collectee souvent par le Scavenger. Les objets qui survivent a 2 collections sont promus dans le old space. Voir V8 en profondeur.
O
Object pooling -- Technique qui réutilisé des objets au lieu de les créer et les laisser collecter. Elimine les allocations dans les boucles chaudes (game loops, traitement de flux). Voir Optimisations mémoire.
Old space -- La zone du heap V8 ou vivent les objets de longue duree. Plus grande que le new space, collectee par le Major GC. C'est ici que se trouvent la plupart des fuites mémoire. Voir V8 en profondeur.
OOM (Out Of Memory) -- Quand un process demande plus de mémoire que ce qui est disponible. En Node.js, ca donne "JavaScript heap out of memory". Dans Docker, le OOM killer tue le process (exit code 137). Voir Mémoire et Docker.
Ownership -- Concept central de Rust. Chaque valeur a exactement un proprietaire. Quand le proprietaire sort du scope, la valeur est libérée. Pas besoin de GC. Voir Comparaison avec d'autres langages.
R
Reachability (accessibilité) -- Un objet est "reachable" s'il existe un chemin de références depuis un GC root jusqu'a lui. C'est le critère du GC pour décider de garder ou supprimer un objet. Voir Le garbage collector.
Référence counting -- Stratégie de gestion mémoire ou chaque objet a un compteur de références. Quand le compteur atteint zero, l'objet est libéré. Utilise par Python et Swift. Ne gere pas les cycles sans aide. Voir Comparaison avec d'autres langages.
Retained size -- Dans un heap snapshot, la quantité de mémoire qui serait libérée si cet objet etait supprime. Inclut tous les objets qu'il retient exclusivement. Voir Chrome DevTools.
Retainer -- Dans un heap snapshot, l'objet (ou la référencé) qui empeche un autre objet d'etre collecte. Trouver le retainer d'un objet qui fuite, c'est trouver la cause de la fuite. Voir Chrome DevTools.
S
Scavenger -- L'algorithme de V8 pour le Minor GC. Copie les objets survivants du "from-space" vers le "to-space" du new space, puis échange les deux espaces. Rapide et efficace pour les objets courts. Voir V8 en profondeur.
Shallow size -- Dans un heap snapshot, la taille de l'objet lui-meme, sans compter ce qu'il référencé. Un tableau de 1000 éléments a un shallow size petit (la structure du tableau) mais un retained size gros (toutes les valeurs). Voir Chrome DevTools.
SharedArrayBuffer -- Un ArrayBuffer qui peut etre partage entre le thread principal et les Workers. Permet la communication sans copie. Necessite les headers COOP/COEP. Voir Arrays et typed arrays.
Stack (pile) -- Zone mémoire LIFO pour les variables locales et les frames d'appel de fonctions. Allocation et desallocation ultra rapides. Taille limitee. Les primitives et les références y vivent. Voir Stack vs Heap.
Stack overflow -- Depassement de la pile d'appels. Se produit généralement avec une recursion infinie ou tres profonde. Erreur fatale : "Maximum call stack size exceeded". Voir Stack vs Heap.
Stop-the-world -- Pause du programme pendant laquelle le GC travaille. Aucun code JavaScript ne s'exécuté. V8 minimise ces pauses avec le marking concurrent, mais elles existent toujours pour certaines phases. Voir Le garbage collector.
Stream -- Abstraction pour traiter des donnees morceau par morceau au lieu de tout charger en mémoire. Node.js a 4 types : Readable, Writable, Transform, Duplex. Voir Streams et backpressure.
T
Transferable -- Interface qui permet de transférer la propriété d'un objet (ArrayBuffer, MessagePort) a un Worker au lieu de le copier. Le thread d'origine perd l'acces. Zero-copy. Voir Arrays et typed arrays.
TypedArray -- Vue typee sur un ArrayBuffer. Uint8Array, Float64Array, Int32Array, etc. Mémoire contigue, acces rapide, taille fixe. Pas d'overhead par élément comme les Array classiques. Voir Arrays et typed arrays.
V
V8 -- Le moteur JavaScript de Google, utilise dans Chrome et Node.js. Compile le JS en code machine (JIT), gere le heap, et exécuté le GC. La plupart des détails mémoire de cette serie sont spécifiques a V8. Voir V8 en profondeur.
W
WeakMap -- Un Map dont les clés sont des références faibles. Si la clé n'est plus référencée ailleurs, l'entree est automatiquement supprimee et la mémoire libérée. Les clés doivent etre des objets. Voir WeakRef et WeakMap.
WeakRef -- Une référencé faible vers un objet. N'empeche pas le GC de collecter l'objet. Tu dois appeler .deref() pour acceder a l'objet, et vérifier qu'il n'est pas undefined (deja collecte). Voir WeakRef et WeakMap.
WeakSet -- Un Set dont les éléments sont des références faibles. Comme WeakMap mais sans valeur associee. Utile pour marquer des objets (par exemple "deja traite") sans les retenir en mémoire. Voir WeakRef et WeakMap.
Worker (Web Worker / Worker Thread) -- Un thread séparé qui a son propre heap et son propre GC. La communication se fait par message (copie structuree) ou par Transferable (zero-copy). Voir Arrays et typed arrays.
Ce glossaire couvre les termes des 21 articles de la serie. Si tu tombes sur un mot inconnu en debuggant une fuite, reviens ici. Et si un terme manque, c'est probablement que je l'ai oublie -- ca arrive.
Résumé
- 40 termes couvrant toute la gestion mémoire en JavaScript et TypeScript.
- Chaque terme renvoie vers l'article qui le traite en détail.
- A garder sous la main pendant les sessions de profiling et de debug.
Precedent : Tester la mémoire