Fonctionnalité Page Cache Limit - Alibaba Cloud Linux - Centre de documentation Alibaba Cloud

Des charges de travail comme Apache Spark peuvent accumuler rapidement une grande quantité de page cache. La majorité de ces pages sont des pages sales (dirty pages), dont la récupération est lente. Si le mécanisme de récupération ne libère pas la mémoire assez vite, le noyau manque de ressources et déclenche une erreur out-of-memory (OOM) inattendue, provoquant ainsi des instabilités applicatives. Page Cache Limit plafonne l'utilisation du page cache par groupe de contrôle mémoire (memcg) et récupère le cache excédentaire dès que la limite est franchie. Cette fonctionnalité empêche la croissance illimitée du page cache et évite les erreurs OOM imprévues. Elle est disponible dans Alibaba Cloud Linux 3 à partir de la version du noyau 5.10.134-14.

Interfaces

Le tableau suivant récapitule toutes les interfaces disponibles. Des descriptions détaillées suivent.

Interface	Description	Valeur par défaut
`/sys/kernel/mm/pagecache_limit/enabled`	Commutateur global d'activation/désactivation	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.enable`	Commutateur d'activation/désactivation par memcg	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.size`	Limite du page cache en octets	`0`
`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.sync`	Mode de récupération : asynchrone (`0`) ou synchrone (`1`)	`0`

`/sys/kernel/mm/pagecache_limit/enabled`

Ce paramètre contrôle le commutateur global de Page Cache Limit. Valeurs valides : 0 et 1.

1 : active Page Cache Limit au niveau global.
0 : désactive Page Cache Limit au niveau global.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.enable`

Ce paramètre gère le commutateur spécifique à chaque memcg. Valeurs valides : 0 et 1.

1 : active Page Cache Limit pour le memcg concerné.
0 : désactive Page Cache Limit pour le memcg concerné.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.size`

Définit l'utilisation maximale du page cache pour un memcg, exprimée en octets. Plage valide : de 0 jusqu'à la valeur de memory.limit_in_bytes du memcg.

0 : désactive Page Cache Limit pour ce memcg, indépendamment de l'état du commutateur global ou de celui du memcg.
Valeur non nulle : restreint l'utilisation du page cache du memcg à cette valeur précise.

Remarque : L'utilisation du page cache d'un memcg correspond à la somme des utilisations du page cache de tous ses memcgs enfants.

`/sys/fs/cgroup/memory/<memcg>/memory.pagecache_limit.sync`

Détermine le mode de récupération de la mémoire. Valeurs valides : 0 et 1.

0 : récupération asynchrone. Le noyau délègue les tâches de récupération aux threads de la file d'attente de travaux en arrière-plan, réduisant ainsi l'impact sur les threads principaux. Si une charge de travail génère du page cache plus rapidement que la file d'attente ne peut le récupérer, le page cache peut temporairement dépasser la limite fixée.
1 : récupération synchrone. La récupération s'exécute dans le contexte du processus actuel et bloque celui-ci jusqu'à la libération d'une quantité suffisante de page cache. Ce mode offre des garanties plus fortes, mais risque de provoquer des pics de latence au niveau du processus.

Fonctionnement

Une fois Page Cache Limit activé, le noyau applique la logique suivante à chaque allocation de page cache pour un processus memcg :

Vérification du memcg actuel. Le noyau vérifie si le memcg a dépassé sa limite de page cache. Il parcourt ensuite la hiérarchie memcg vers le haut en examinant les valeurs memory.pagecache_limit de chaque memcg parent. Si la valeur d'un parent est 0, la fonctionnalité est désactivée pour ce parent et tous ses descendants ; le page cache n'y est alors soumis à aucune restriction.
Sélection du mode de récupération. Lorsque le memcg dépasse sa limite, le noyau consulte memory.pagecache_limit.sync afin de choisir entre une récupération asynchrone ou synchrone.

Récupération du page cache. Le comportement varie selon le mode choisi :

Mode	Cibles de récupération
Synchrone	Par défaut, uniquement les pages de fichiers non mappées. Après plus de quatre analyses, les pages de fichiers mappées deviennent également éligibles.
Asynchrone	Par défaut, les pages de fichiers mappées et non mappées. Après plus de deux analyses, les pages sales deviennent aussi éligibles.

Le diagramme suivant illustre le flux complet de traitement :

Types de pages mémoire

Type	Description
Pages de fichiers non mappées	Pages non associées à un fichier. Elles contiennent généralement des données temporaires privées qui ne sont pas persistées sur disque.
Pages de fichiers mappées	Pages associées à des fichiers. Elles permettent aux processus de lire et d'écrire directement des données de fichiers en mémoire.
Pages sales	Pages de fichiers mappées modifiées mais pas encore écrites sur disque. Leur récupération est lente car elles doivent d'abord être vidées.

Configuration de Page Cache Limit

Cet exemple crée un page cache de 20 Mio, impose une limite de 10 Mio, puis vérifie que la fonctionnalité récupère bien l'excédent.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

Une instance Elastic Compute Service (ECS) exécutant Alibaba Cloud Linux 3, avec la version du noyau 5.10.134-14 ou ultérieure
Un accès sudo sur l'instance

Activation et configuration de la fonctionnalité

Connectez-vous à l'instance ECS. Pour obtenir des instructions, consultez Utiliser Workbench pour se connecter à une instance Linux.

Activez Page Cache Limit au niveau global.

sudo sh -c 'echo 1 > /sys/kernel/mm/pagecache_limit/enabled'

Créez un répertoire memcg. Cet exemple utilise /sys/fs/cgroup/memory/test/.
```
sudo mkdir -p /sys/fs/cgroup/memory/test/
```

Définissez la limite du page cache à 10 Mio (10 485 760 octets).

sudo sh -c 'echo 10485760 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.size'

Configurez le mode de récupération. Choisissez l'une des options suivantes selon votre charge de travail :
- Récupération asynchrone :
```
sudo sh -c 'echo 0 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.sync'
```
- Récupération synchrone :
```
sudo sh -c 'echo 1 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.sync'
```

Activez Page Cache Limit pour le memcg.

sudo sh -c 'echo 1 > /sys/fs/cgroup/memory/test/memory.pagecache_limit.enable'

Création d'un page cache de test

Installez le package libcgroup qui fournit la commande cgexec.
```
sudo yum install libcgroup-tools
```

Créez un fichier de test de 20 Mio et lisez-le sous le memcg test pour générer 20 Mio de page cache.

sudo dd if=/dev/zero of=./testfile bs=1M count=20 oflag=direct
sudo cgexec -g "memory:test" cat ./testfile > /dev/null

Vérification des résultats

Vérifiez l'utilisation du page cache. Le champ cache dans memory.stat indique le volume total de page cache consommé par le memcg.
```
grep cache /sys/fs/cgroup/memory/test/memory.stat
```
La sortie devrait afficher une valeur cache d'environ 10 543 104 octets (~10 Mio), confirmant que l'utilisation du page cache est bien plafonnée à la limite configurée.
Vérifiez le volume de page cache récupéré. Le champ pagecache_limit_reclaimed_kb dans memory.exstat affiche le nombre cumulé de kilo-octets de page cache récupérés par la fonctionnalité.
```
cat /sys/fs/cgroup/memory/test/memory.exstat
```
La sortie devrait indiquer une valeur pagecache_limit_reclaimed_kb d'environ 10 108 Ko (~10 Mio), confirmant la récupération de 10 Mio de page cache excédentaire.

Résultat : Un page cache de 20 Mio a été créé. Page Cache Limit a plafonné l'utilisation à 10 Mio et a récupéré les 10 Mio restants comme prévu.

Remarque : Si pagecache_limit_reclaimed_kb est supérieur aux attentes, cela peut provenir d'une lecture anticipée séquentielle excessive. Réduisez la taille de lecture anticipée pour le périphérique disque, puis effectuez un nouveau test : echo 128 | sudo tee /sys/block/<disk-device>/queue/read_ahead_kb Remplacez <disk-device> par le nom de votre périphérique disque (par exemple, vda ). Le paramètre read_ahead_kb contrôle le nombre de kilo-octets préchargés par le noyau lors des lectures séquentielles. Sa réduction permet de limiter les allocations inutiles de page cache.

Étapes suivantes

Récupération asynchrone backend Memcg — Découvrez cette fonctionnalité complémentaire qui gère la pression mémoire classique sans bloquer les processus.