Mesurer la mémoire utilisée ​

Mesurer la consommation de mémoire de votre application Node.js est important pour optimiser les performances et éviter les fuites de mémoire. Vous pouvez mesurer la mémoire utilisée par Node.js de plusieurs façons.

Commande process.memoryUsage(): ​

Node.js fournit une méthode intégrée, process.memoryUsage(), qui retourne un objet contenant des informations sur l'utilisation de la mémoire.

Voici un exemple simple d'utilisation de process.memoryUsage():

const memoryUsage = process.memoryUsage();
console.log(memoryUsage);

const memoryUsage = process.memoryUsage();
console.log(memoryUsage);

L'objet retourné contiendra les informations suivantes:

• rss (Resident Set Size): La quantité de mémoire assignée à l'application dans la RAM.
• heapTotal: La taille totale de la Heap allouée.
• heapUsed: La quantité de mémoire utilisée dans la Heap.
• external: La mémoire utilisée par les objets gérés par V8, comme les tampons et les tableaux.

Utiliser les Outils de Développement de Chrome: ​

Si vous déboguez votre application avec --inspect, vous pouvez utiliser l'onglet Memory des outils de développement de Chrome pour prendre des instantanés de la mémoire et identifier les fuites de mémoire.

Exemple de Fuite de Mémoire: ​

Un exemple classique qui pourrait utiliser beaucoup de mémoire RAM en Node.js est celui où vous créez et stockez de nombreux objets en mémoire, par exemple dans un tableau, sans jamais les supprimer. Cela peut être simulé à l'aide d'une boucle qui crée constamment de nouveaux objets et les ajoute à un tableau.

Voici un exemple simple qui générera une consommation de RAM élevée au fil du temps. Notez que cet exemple est à titre éducatif uniquement et ne doit pas être utilisé dans un environnement de production ou de développement réel.

let bigArray = [];

function createBigObject() {
  let obj = {};
  for (let i = 0; i < 10000; i++) {
    obj[i] = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  }
  return obj;
}

function fillMemory() {
  while (true) {
    bigArray.push(createBigObject());
  }
}

fillMemory();

let bigArray = [];

function createBigObject() {
  let obj = {};
  for (let i = 0; i < 10000; i++) {
    obj[i] = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
  }
  return obj;
}

function fillMemory() {
  while (true) {
    bigArray.push(createBigObject());
  }
}

fillMemory();

Dans cet exemple:

• Nous avons une fonction createBigObject() qui crée un objet contenant beaucoup de chaînes de caractères.
• La fonction fillMemory() crée une boucle infinie où de nouveaux objets sont constamment créés et ajoutés à bigArray.
• La mémoire continuera à augmenter indéfiniment tant que cette boucle s'exécute, car de plus en plus d'objets sont ajoutés à bigArray et aucun n'est supprimé.

Comment Exécuter: ​

• Copiez ce code dans un fichier, par exemple memoryLeakExample.js.
• Exécutez le fichier avec Node.js dans un terminal: node memoryLeakExample.js.

Comment Vérifier la Consommation de Mémoire: ​

Lorsque vous prenez un instantané de la heap (heap snapshot) dans les outils de développement de Chrome, vous verrez plusieurs termes et métriques, dont "Shallow Size", "Retained Size", et "Distance". Ces termes sont utilisés pour analyser l'utilisation de la mémoire de votre application.

Shallow Size & Retained Size ​

La taille shallow d'un objet représente la quantité de mémoire utilisée par l'objet lui-même, sans compter les objets référencés. C'est, en d'autres termes, la quantité de mémoire que vous récupéreriez immédiatement si vous supprimiez l'objet (et uniquement cet objet).

La taille retained d'un objet est la quantité totale de mémoire que vous récupéreriez si vous supprimiez cet objet et tous les autres objets qui sont inaccessibles sans lui. En d'autres termes, c'est la somme de la taille shallow de l'objet et de toutes les tailles shallow des objets qui seraient libérés si cet objet était supprimé.

Distance: ​

La distance dans un instantané de la heap représente la distance minimale de l'objet par rapport à la racine de la heap, en nombre d'arêtes. Une distance plus courte signifie que l'objet est plus proche de la racine de la heap, et une distance plus longue signifie qu'il est plus éloigné.

La notion de "distance" dans le contexte de l'analyse de la mémoire en informatique se réfère généralement à la distance entre un objet spécifique dans le tas de mémoire (heap) et la racine de l'arbre d'objets.

Exemple de Code (longue distance) ​

let root = { name: "root" }; // objet racine
let current = root; // objet courant, initialement défini comme l'objet racine

// Création d'une chaîne d'objets imbriqués
for (let i = 0; i < 10; i++) {
  current.child = { name: `child${i}` }; // crée un nouvel objet et l'assigne à la propriété "child" de l'objet courant
  current = current.child; // déplace la référence de l'objet courant vers le nouvel objet enfant
}

console.log(root);

let root = { name: "root" }; // objet racine
let current = root; // objet courant, initialement défini comme l'objet racine

// Création d'une chaîne d'objets imbriqués
for (let i = 0; i < 10; i++) {
  current.child = { name: `child${i}` }; // crée un nouvel objet et l'assigne à la propriété "child" de l'objet courant
  current = current.child; // déplace la référence de l'objet courant vers le nouvel objet enfant
}

console.log(root);

Dans cet exemple:

• Nous avons un objet root initial.
• Une boucle crée une série d'objets imbriqués (chaque objet est un "enfant" du précédent), créant une chaîne d'objets.

Analyse de la Distance: ​

• L'objet root aurait une distance de 0, car il est directement accessible.
• root.child (i.e., child0) aurait une distance de 1 de root.
• root.child.child (i.e., child1) aurait une distance de 2 de root, et ainsi de suite.
• Le dernier enfant créé aurait une distance de 10 de l'objet root, car il est imbriqué à travers 10 niveaux d'objets.

Cet exemple est simplifié, mais il illustre comment les objets peuvent être imbriqués ou référencés à travers plusieurs niveaux, créant une "longue distance" entre la racine et l'objet final dans la chaîne d'objets. Dans des applications réelles, cela peut se produire de manière plus complexe à travers des structures de données imbriquées, des closures, des callbacks, et d'autres constructions de code.

Utiliser Efficacement le Heap Snapshot pour les Fuites de Mémoire: ​

1. Prendre plusieurs instantanés:

   • Prenez un instantané de la heap au début.
   • Exécutez ensuite des parties de votre application susceptibles de causer des fuites de mémoire.
   • Prenez d'autres instantanés pour comparer les résultats.

2. Comparer les Instantanés:

   • Comparez les instantanés de la heap pour voir quels objets restent en mémoire.
   • Les objets qui ne sont pas libérés peuvent être à l'origine de fuites de mémoire.

3. Identifier les Objets Conservés:

   • Recherchez les objets qui ont une grande taille retained, car cela peut indiquer qu'ils conservent d'autres objets en mémoire.
   • Examinez ces objets pour voir pourquoi ils ne sont pas libérés.

4. Recherchez les Détenteurs de Mémoire:

   • Les détenteurs de mémoire sont des objets qui retiennent d'autres objets en mémoire.
   • Examinez les relations entre les objets et identifiez ceux qui retiennent inutilement d'autres objets.

5. Inspecter la Distance:

   • Considérez la distance pour comprendre si un objet est retenu à cause d'une référence profondément imbriquée.
   • Les objets avec une distance plus courte sont généralement créés et référencés directement par le code de l'application, tandis que ceux avec une distance plus longue peuvent être créés indirectement.

6. Références et Chemins:

   • Utilisez l'onglet "References" pour voir quelles sont les références qui retiennent l'objet.
   • Utilisez l'onglet "Paths" pour voir le chemin de références qui retient l'objet.

Retained Size ​

La taille "retained" (retenue) d'un objet en mémoire est un concept que l'on utilise lors de l'analyse de la mémoire dans les applications, notamment pour identifier les fuites de mémoire. Elle est généralement utilisée dans le contexte des outils de profiling de mémoire comme les DevTools de Chrome pour les applications JavaScript, y compris Node.js.

Définition de la Taille Retained: ​

La "Retained Size" d'un objet représente la quantité totale de mémoire qui serait libérée si cet objet était supprimé de la mémoire. Plus précisément, elle comprend la mémoire utilisée par l'objet lui-même (sa "Shallow Size") ainsi que la mémoire utilisée par d'autres objets qui sont référencés directement ou indirectement par cet objet et qui ne sont accessibles (et donc retenus en mémoire) que par cet objet.

Exemple: ​

Imaginons que vous ayez trois objets en mémoire: A, B, et C.

• A a une référence à B.
• B a une référence à C.

Si A est le seul objet qui a une référence à B, et B est le seul objet qui a une référence à C, alors la "Retained Size" de A inclura la "Shallow Size" de A, B, et C, car si vous supprimez A, alors B et C seront également éligibles pour la collecte des ordures (garbage collection), étant donné qu'il n'y a plus de références à B et C.

Code Exemple: ​

Voici un exemple concret d’un scénario où vous pourriez rencontrer une situation de grande taille "retained" dans un serveur web Node.js. Supposons que vous ayez un serveur qui conserve tous les objets de requête dans un tableau pour une raison quelconque (cet exemple est simplifié et à des fins éducatives, et il n'est généralement pas conseillé de conserver toutes les requêtes).

import express from 'express';
const app = express();
const port = 3000;

let requests = []; // Pour stocker tous les objets de requête

app.get('/', (req, res) => {
  requests.push(req); // Ajouter chaque objet de requête au tableau
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

import express from 'express';
const app = express();
const port = 3000;

let requests = []; // Pour stocker tous les objets de requête

app.get('/', (req, res) => {
  requests.push(req); // Ajouter chaque objet de requête au tableau
  res.send('Hello World!');
});

app.listen(port, () => {
  console.log(`Server is running at http://localhost:${port}`);
});

Scénario: ​

Dans cet exemple, à chaque requête reçue sur l'endpoint '/', l'objet req (qui représente la requête HTTP entrante) est ajouté au tableau requests. Si cet objet req a des références à d'autres objets, ces objets sont également retenus en mémoire tant que l'objet req est dans le tableau requests.

Retained Size: ​

Dans ce cas, la taille "retained" de chaque objet req dans le tableau serait la somme de la taille "shallow" de l'objet req lui-même et des tailles "shallow" de tous les objets accessibles depuis req.

Analyse avec Chrome DevTools: ​

Pour analyser la taille "retained" et identifier les fuites de mémoire, vous pouvez prendre un Heap Snapshot à l'aide de Chrome DevTools. Vous aurez besoin d'exécuter votre serveur Node.js avec l'option --inspect, puis connecter Chrome DevTools à l'instance en cours d'exécution de Node.js.

Voici comment faire:

1. Exécuter le Serveur avec l'Option --inspect:

   sh

   node --inspect server.js

   node --inspect server.js

2. Ouvrez Chrome et Naviguez vers:

   chrome://inspect

   chrome://inspect

3. Connectez-vous à l'Instance de Node.js: Sous "Remote Target", vous devriez voir votre instance de Node.js en cours d'exécution. Cliquez sur "inspect".

4. Prenez un Heap Snapshot:

   • Allez à l'onglet "Memory".
   • Cliquez sur "Take snapshot".

5. Analysez la Taille Retained:

   • Examinez les objets dans le snapshot et vérifiez leur taille "retained".

En faisant cela, vous pouvez identifier les objets qui occupent le plus de mémoire et optimiser votre code en conséquence. Dans le cas de cet exemple, vous constaterez que le tableau requests et ses objets de requête ont une grande taille "retained", ce qui indique qu'ils retiennent beaucoup de mémoire.