# Surveiller la mémoire des processus .NET sous Linux/WSL
Les travaux .NET gourmands en ressources, tels que l'OCR, la génération de PDF ou le traitement d'images, peuvent être difficiles à dimensionner dans des environnements contraints comme WSL (Windows Subsystem for Linux) ou les conteneurs Linux. Vous pouvez enregistrer la consommation de mémoire d'un processus en temps réel directement depuis une application console, ou la surveiller de l'extérieur avec les outils Linux standard.
## Prérequis
- SDK .NET installé, version `5.0` ou ultérieure.
- Un environnement Linux, soit natif soit via WSL.
- Une application console .NET de base.
## Solution
### 1. Enregistrer l'utilisation de la mémoire sur la console
Lisez la taille de la mémoire privée du processus et imprimez-la en mégaoctets :
```csharp
using System;
using System.Diagnostics;
class Program
{
static void Main(string[] args)
{
// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)
// Log memory usage
Process currentProcess = Process.GetCurrentProcess();
long memorySize = currentProcess.PrivateMemorySize64; // In bytes
Console.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");
}
}
```
`PrivateMemorySize64` retourne la quantité de mémoire, en octets, que le processus a allouée exclusivement et ne partage pas avec d'autres processus. C'est un indicateur solide de la lourdeur de votre application.
### 2. Suivre la mémoire en continu
Pour un processus de longue durée, enveloppez la lecture dans une boucle pour échantillonner l'utilisation au fil du temps :
```csharp
while (true)
{
var memory = Process.GetCurrentProcess().PrivateMemorySize64;
Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");
Thread.Sleep(5000); // Log every 5 seconds
}
```
L'appel `Thread.Sleep(5000)` régule la journalisation à une lecture toutes les cinq secondes. Dirigez la sortie vers un fichier ou un autre processus, ou utilisez-la pour envoyer des alertes lorsque l'utilisation dépasse un seuil.
#### Sortie Console
```txt
Memory Usage: 214 MB
```
### Option: Surveillez de l'extérieur avec les outils Linux
Pour surveiller un processus depuis l'extérieur de l'application, utilisez l'une des utilitaires standards. `<pid>` est l'ID de processus, le numéro unique que le système d'exploitation attribue à chaque processus en cours.
**`top` ou `htop` :** surveillez un seul processus en direct.
```bash
top -p <pid>
```
**`ps` :** imprimez un instantané unique des champs de mémoire.
```bash
ps -o pid,vsz,rss,comm -p <pid>
```
Ici `VSZ` est la taille de la mémoire virtuelle en Ko et `RSS` est la taille de l'ensemble résident, la mémoire physique utilisée.
**`smem` :** installez-le pour une ventilation plus détaillée par processus.
```bash
sudo apt install smem
smem -p <pid>
```
## Bonnes pratiques
- Exécutez le suivi de la mémoire dans des environnements de test avant le déploiement en production.
- Pour les services ou les API de longue durée, intégrez une pile de métriques telle que Prometheus ou Grafana.
- Réservez `GC.Collect()` pour le débogage uniquement.
[[w:(N'appelez pas GC.Collect() dans le code de production ; utilisez-le uniquement pendant le débogage.)]]
Les travaux .NET gourmands en ressources, tels que l'OCR, la génération de PDF ou le traitement d'images, peuvent être difficiles à dimensionner dans des environnements contraints comme WSL (Windows Subsystem for Linux) ou les conteneurs Linux. Vous pouvez enregistrer la consommation de mémoire d'un processus en temps réel directement depuis une application console, ou la surveiller de l'extérieur avec les outils Linux standard.
Prérequis
SDK .NET installé, version 5.0 ou ultérieure.
Un environnement Linux, soit natif soit via WSL.
Une application console .NET de base.
Solution
1. Enregistrer l'utilisation de la mémoire sur la console
Lisez la taille de la mémoire privée du processus et imprimez-la en mégaoctets :
using System;using System.Diagnostics;class Program{static voidMain(string[] args){// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)// Log memory usageProcess currentProcess = Process.GetCurrentProcess();long memorySize = currentProcess.PrivateMemorySize64; // In bytesConsole.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");}}
using System;
using System.Diagnostics;
class Program
{
static void Main(string[] args)
{
// Trigger your memory-consuming logic here (e.g., OCR, PDF generation, etc.)
// Log memory usage
Process currentProcess = Process.GetCurrentProcess();
long memorySize = currentProcess.PrivateMemorySize64; // In bytes
Console.WriteLine($"Memory Usage: {memorySize / (1024 * 1024)} MB");
}
}
C#
PrivateMemorySize64 retourne la quantité de mémoire, en octets, que le processus a allouée exclusivement et ne partage pas avec d'autres processus. C'est un indicateur solide de la lourdeur de votre application.
2. Suivre la mémoire en continu
Pour un processus de longue durée, enveloppez la lecture dans une boucle pour échantillonner l'utilisation au fil du temps :
while (true){var memory = Process.GetCurrentProcess().PrivateMemorySize64;Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");Thread.Sleep(5000); // Log every 5 seconds}
while (true)
{
var memory = Process.GetCurrentProcess().PrivateMemorySize64;
Console.WriteLine($"Memory Usage: {memory / (1024 * 1024)} MB");
Thread.Sleep(5000); // Log every 5 seconds
}
C#
L'appel Thread.Sleep(5000) régule la journalisation à une lecture toutes les cinq secondes. Dirigez la sortie vers un fichier ou un autre processus, ou utilisez-la pour envoyer des alertes lorsque l'utilisation dépasse un seuil.
Sortie Console
Memory Usage: 214 MB
Memory Usage: 214 MB
Text
Option: Surveillez de l'extérieur avec les outils Linux
Pour surveiller un processus depuis l'extérieur de l'application, utilisez l'une des utilitaires standards. <pid> est l'ID de processus, le numéro unique que le système d'exploitation attribue à chaque processus en cours.
top ou htop : surveillez un seul processus en direct.
top -p <pid>
top -p <pid>
SHELL
ps : imprimez un instantané unique des champs de mémoire.
ps -o pid,vsz,rss,comm -p <pid>
ps -o pid,vsz,rss,comm -p <pid>
SHELL
Ici VSZ est la taille de la mémoire virtuelle en Ko et RSS est la taille de l'ensemble résident, la mémoire physique utilisée.
smem : installez-le pour une ventilation plus détaillée par processus.
sudo apt install smemsmem -p <pid>
sudo apt install smem
smem -p <pid>
SHELL
Bonnes pratiques
Exécutez le suivi de la mémoire dans des environnements de test avant le déploiement en production.
Pour les services ou les API de longue durée, intégrez une pile de métriques telle que Prometheus ou Grafana.
Réservez GC.Collect() pour le débogage uniquement.
Avertissement: N'appelez pas GC.Collect() dans le code de production ; utilisez-le uniquement pendant le débogage.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
