Memcg backend asynchronous reclaim - Alibaba Cloud Linux - Centre de documentation Alibaba Cloud

Lorsque l'utilisation mémoire d'un memcg atteint sa limite, le noyau déclenche une récupération directe de la mémoire. Cette opération synchrone s'exécute dans le chemin d'allocation mémoire et bloque le processus en cours. Pour éliminer cette latence, Alibaba Cloud Linux propose une récupération asynchrone en arrière-plan pour les memcgs. Le noyau récupère ainsi la mémoire en arrière-plan avant que l'utilisation n'atteigne la limite stricte, évitant à vos processus d'attendre la fin de la récupération.

Cette fonctionnalité est disponible sur :

Alibaba Cloud Linux 2 avec une version du noyau 4.19.81-17.al7 ou ultérieure
Alibaba Cloud Linux 3 avec une version du noyau 5.10.134-12.al8 ou ultérieure

Avertissement

Prenez en compte les comportements suivants avant d'activer cette fonctionnalité :

Une allocation mémoire dans un memcg existant peut déclencher récursivement une récupération asynchrone en arrière-plan dans le cgroup parent.
La récupération débute au niveau du memcg où elle a été déclenchée, puis se propage de haut en bas dans la hiérarchie des cgroups.
Si memory.high est défini à une valeur inférieure à memory.limit_in_bytes, alors memory.wmark_high et memory.wmark_low sont calculés à partir de memory.high plutôt que de memory.limit_in_bytes.

Fonctionnement

Cette fonctionnalité introduit un mécanisme basé sur des seuils (watermarks). Définissez memory.wmark_ratio comme pourcentage de la limite du memcg pour établir un seuil haut (memory.wmark_high). Lorsque l'utilisation mémoire franchit ce seuil, le noyau lance une récupération asynchrone en arrière-plan. La récupération s'arrête dès que l'utilisation passe sous un seuil bas (memory.wmark_low), dérivé de memory.wmark_high avec un facteur d'échelle configurable.

Ce mécanisme crée une zone tampon : la récupération s'exécute en arrière-plan avant que la limite stricte ne soit atteinte, prévenant ainsi les blocages soudains causés par la récupération directe.

Référence des interfaces

`memory.wmark_ratio`

Lecture-écriture. Active la fonctionnalité et définit le seuil haut comme pourcentage de la limite du memcg.

Valeurs valides : 0–100
Valeur par défaut : 0 (fonctionnalité désactivée)
Une valeur non nulle active la fonctionnalité et entraîne le recalcul de memory.wmark_high.

`memory.wmark_high`

Lecture seule. Seuil d'utilisation mémoire déclenchant la récupération asynchrone en arrière-plan.

Formule : memory.wmark_high = memory.limit_in_bytes x memory.wmark_ratio / 100
Si la fonctionnalité est désactivée (memory.wmark_ratio = 0), cette valeur prend la valeur maximale possible afin d'empêcher tout déclenchement.
Absent du répertoire racine du memcg.

`memory.wmark_low`

Lecture seule. Seuil d'utilisation mémoire en dessous duquel la récupération asynchrone en arrière-plan s'arrête.

Formule : memory.wmark_low = memory.wmark_high - memory.limit_in_bytes x memory.wmark_scale_factor / 10000
Absent du répertoire racine du memcg.

`memory.wmark_scale_factor`

Lecture-écriture. Contrôle l'écart entre memory.wmark_high et memory.wmark_low.

Unité : 0,01 % de la limite du memcg
Valeurs valides : 1–1000
Valeur par défaut : 50 (soit 0,50 % de la limite du memcg), héritée du cgroup parent lors de la création du memcg
Absent du répertoire racine du memcg.

Activer la récupération asynchrone en arrière-plan

L'exemple suivant crée un memcg de test, fixe une limite mémoire de 1 Go, active la fonctionnalité avec un seuil à 95 %, puis vérifie les valeurs résultantes des interfaces.

Créez un memcg de test.
```
sudo mkdir /sys/fs/cgroup/memory/test/
```

Définissez la limite mémoire à 1 Go.

sudo sh -c 'echo 1G > /sys/fs/cgroup/memory/test/memory.limit_in_bytes'

Activez la récupération asynchrone en arrière-plan en définissant memory.wmark_ratio à 95. Cela configure memory.wmark_high à 95 % de la limite du memcg.
```
sudo sh -c 'echo 95 > /sys/fs/cgroup/memory/test/memory.wmark_ratio'
```
Vérifiez la configuration en relisant les valeurs des interfaces.

Consultez memory.wmark_scale_factor. La valeur par défaut héritée est 50, ce qui correspond à 0,50 % de la limite du memcg.
```
cat /sys/fs/cgroup/memory/test/memory.wmark_scale_factor
```
Consultez memory.wmark_high pour vérifier le seuil haut.
```
cat /sys/fs/cgroup/memory/test/memory.wmark_high
```
Consultez memory.wmark_low pour vérifier le seuil bas.
```
cat /sys/fs/cgroup/memory/test/memory.wmark_low
```