Activer la fonctionnalité cgroup writeback

Dans Alibaba Cloud Linux 2 (version du noyau 4.19.36-12.al7 et ultérieures) et Alibaba Cloud Linux 3, la fonctionnalité cgroup writeback est disponible pour l'interface kernel cgroup v1. Cette fonctionnalité permet de limiter le débit des E/S mises en mémoire tampon.

Informations générales

Les groupes de contrôle, appelés cgroups dans cette rubrique, sont une fonctionnalité du noyau Linux qui permet d'allouer des ressources. Les cgroups existent en deux versions : cgroup v1 et cgroup v2. Pour plus d'informations, consultez la section What are Control Groups du Guide de gestion des ressources. Cette rubrique décrit comment activer la fonctionnalité cgroup writeback pour cgroup v1 afin de limiter le débit des E/S mises en mémoire tampon des processus.

Limites

Après avoir activé la fonctionnalité cgroup writeback, assurez-vous que le mappage entre le sous-système de mémoire (memcg) et le sous-système d'E/S (blkcg) respecte les règles décrites dans cette section. Cela est nécessaire pour limiter le débit des E/S mises en mémoire tampon des processus.

La fonctionnalité cgroup writeback requiert que memcg et blkcg fonctionnent conjointement pour limiter le débit des E/S mises en mémoire tampon. Par défaut, les sous-systèmes de contrôle de cgroup v1 ne fonctionnent pas ensemble. Vous devez donc connecter memcg et blkcg selon une règle spécifique : chaque memcg doit être mappé à un seul blkcg. Le mappage peut être de type un-à-un ou plusieurs-à-un, mais pas un-à-plusieurs ni plusieurs-à-plusieurs.

Par exemple, pour limiter le débit des E/S mises en mémoire tampon des processus A et B, les contraintes suivantes s'appliquent.

Si A et B appartiennent à des memcgs différents, ils peuvent être mappés à des blkcgs différents dans une relation un-à-un. Par exemple, A appartient à memcg1 et blkcg1, et B appartient à memcg2 et blkcg0.
Si A et B appartiennent à des memcgs différents, ils peuvent également être mappés au même blkcg. Par exemple, A appartient à memcg1 et B appartient à memcg2, mais A et B appartiennent tous deux à blkcg2.
Si A et B appartiennent au même memcg, ils doivent être mappés au même blkcg. Par exemple, A et B peuvent tous deux appartenir à memcg0 et blkcg3.

Pour éviter tout problème inattendu après l'activation de cgroup writeback, définissez l'interface cgroup.procs pour le blkcg avant de limiter le débit des E/S mises en mémoire tampon. Écrivez un ID de processus dans cette interface pour garantir un mappage blkcg unique. Vous pouvez également utiliser des outils pour afficher le mappage entre memcg et blkcg. Pour plus d'informations, consultez Confirmer le mappage entre memcg et blkcg.

Lors des opérations et de la maintenance (O&M), un processus peut être déplacé vers un autre cgroup. Selon la règle de mappage, aucun problème ne survient si un processus se déplace entre des memcgs. En revanche, si un processus se déplace entre des blkcgs, un problème se produit. Pour prévenir cela, le code de la fonctionnalité inclut une règle : si un processus dans un blkcg actif est déplacé vers un autre blkcg, le mappage est réinitialisé vers le blkcg racine. La fonctionnalité de limitation de débit n'est alors plus efficace, car un seuil de limitation de débit n'est généralement pas défini sur le blkcg racine.

Important

Bien que le code du noyau inclue une règle pour éviter les problèmes inattendus, évitez de déplacer des processus entre des blkcgs pendant les opérations.

La fonctionnalité cgroup writeback est désactivée par défaut pour l'interface cgroup v1. Suivez ces étapes pour l'activer.

Ajoutez le champ cgwb_v1 à l'aide de la commande grubby pour activer la fonctionnalité.
Dans cet exemple, la version du noyau est 4.19.36-12.al7.x86_64. Remplacez-la par votre version réelle du noyau. Exécutez la commande uname -r pour vérifier votre version du noyau.
```
sudo grubby --update-kernel="/boot/vmlinuz-4.19.36-12.al7.x86_64" --args="cgwb_v1"
```
Redémarrez le système pour que les modifications prennent effet.
```
sudo reboot
```
Exécutez la commande suivante pour lire le fichier kernel /proc/cmdline et confirmez que les paramètres de ligne de commande du noyau incluent le champ cgwb_v1. Cela active les interfaces blkio.throttle.write_bps_device et blkio.throttle.write_iops_device dans le blkcg pour limiter le débit des E/S mises en mémoire tampon.
```
cat /proc/cmdline | grep cgwb_v1
```

Remarque

Dans un environnement Kubernetes (k8s), après avoir activé la fonctionnalité cgroup writeback, fusionnez également les sous-systèmes cgroup de mémoire et de blkio. Cela empêche l'échec de la limitation de débit si un processus est déplacé.

Fusionnez les sous-systèmes cgroup de mémoire et de blkio.
1. Modifiez le fichier system.conf.
```
sudo vim /etc/systemd/system.conf
```
2. Modifiez la configuration JoinControllers. Par exemple :
```
JoinControllers=cpu,cpuacct net_cls,net_prio memory,blkio
```
3. Appuyez sur la touche Échap pour quitter le mode édition. Saisissez ensuite :wq pour enregistrer et quitter.
Exécutez la commande suivante pour reconstruire l'image initiale du disque RAM. Cela garantit que les modifications de configuration systemd prennent effet.
```
sudo dracut /boot/initramfs-4.19.36-12.al7.x86_64.img 4.19.36-12.al7.x86_64 --force
```
Exécutez la commande suivante pour redémarrer le système.
```
sudo reboot
```
Exécutez la commande suivante pour vérifier que les sous-systèmes de mémoire et de blkio sont fusionnés.
```
ls /sys/fs/cgroup
```

Vérifier l'efficacité de cgroup writeback

Cet exemple simule deux processus générant des E/S pour vérifier que la fonctionnalité cgroup writeback est efficace.

Remarque

La commande dd fournit un retour rapide. Utilisez la commande iostat pour afficher les résultats.
La commande dd écrit les données de manière séquentielle. Lors d'une actualisation séquentielle des E/S, le système écrit les données par blocs de 1 Mo. Définissez donc le seuil blkio.throttle.write_bps_device sur une valeur d'au moins 1 Mo (1048576). Si vous définissez une valeur inférieure à 1 Mo, le processus d'E/S risque de se bloquer.

Simulez deux processus générant des E/S. Comme l'exigent les limites, définissez d'abord l'interface cgroup.procs du blkcg.

sudo mkdir /sys/fs/cgroup/blkio/blkcg1
sudo mkdir /sys/fs/cgroup/memory/memcg1
sudo bash -c "echo $$ > /sys/fs/cgroup/blkio/blkcg1/cgroup.procs"    # $$ is your process ID
sudo bash -c "echo $$ > /sys/fs/cgroup/memory/memcg1/cgroup.procs"    # $$ is your process ID

Utilisez l'interface blkio.throttle.write_bps_device dans le blkcg pour limiter le débit des E/S mises en mémoire tampon.

sudo bash -c "echo 254:48 10485760 > /sys/fs/cgroup/blkio/blkcg1/blkio.throttle.write_bps_device"    # Set the disk write-back rate limit to 10 MB/s based on the device number.

Utilisez la commande dd sans le paramètre oflag=sync pour générer des E/S asynchrones mises en cache.
```
sudo dd if=/dev/zero of=/mnt/vdd/testfile bs=4k count=10000
```
Utilisez l'outil iostat pour interroger les résultats. Vérifiez la colonne wMB/s dans la sortie. Si le débit est limité à environ 10 Mo/s, la fonctionnalité cgroup writeback fonctionne correctement.
```
iostat -xdm 1 vdd
```

Confirmer le mappage entre memcg et blkcg

Utilisez l'une des méthodes suivantes pour confirmer que le mappage entre memcg et blkcg est de type un-à-un ou plusieurs-à-un.

Affichez le mappage entre memcg et blkcg.
```
sudo cat /sys/kernel/debug/bdi/bdi_wb_link
```
La sortie d'exemple suivante montre que memcg et blkcg ont un mappage un-à-un.
```
memory     <--->     blkio
memcg1:   35 <---> blkcg1:   48
```

Utilisez l'outil de surveillance du noyau ftrace.

Activez l'outil ftrace.

sudo bash -c "echo 1 > /sys/kernel/debug/tracing/events/writeback/insert_memcg_blkcg_link/enable"

Affichez les informations de sortie.
```
sudo cat /sys/kernel/debug/tracing/trace_pipe
```
La sortie d'exemple suivante affiche memcg_ino=35 blkcg_ino=48. Cela indique que memcg et blkcg ont un mappage un-à-un.
```
<...>-1537  [006] ....    99.511327: insert_memcg_blkcg_link: memcg_ino=35 blkcg_ino=48 old_blkcg_ino=0
```