Ensembles de CPU exclusifs¶

Si un cpuset est marqué avec cpu_exclusive ou mem_exclusive, aucun autre cpuset, autre que des ancêtres ou descendants directs, peuvent partager des CPU ou des nœuds mémoire avec ce cpuset.

Un cpuset dont mem_exclusive est activé restreint les allocations du noyau pour les pages des tampons de cache et autres données internes du noyau communément partagées par le noyau au travers différents utilisateurs. Tous les cpusets, que mem_exclusive soit activé ou non, restreignent l'allocation de mémoire depuis l'espace utilisateur. Ceci permet de configurer un système de telle sorte que différentes tâches puissent partager des données du noyau, tout en isolant toutes les allocations en mode utilisateur des tâches dans leur propre cpuset. Pour ceci, il faut créer un gros cpuset, avec mem_exclusive activé, pour contenir toutes les tâches, et créer des cpuset fils sans mem_exclusive pour chacune des tâches. Seule une petite partie de la mémoire du noyau, comme les requêtes des gestionnaires d'interruptions, est autorisée à être placée sur des nœuds mémoire en dehors d'un cpuset, même si mem_exclusive est activé.

Hardwall¶

Un cpuset pour lequel mem_exclusive ou mem_hardwall est activé est un cpuset hardwall. Un cpuset hardwall restreint les allocations mémoire du noyau pour les pages, tampons et toutes autre données partagés fréquemment par le noyau au travers différents utilisateurs. Tous les cpusets, hardwall ou non, restreignent les allocations mémoire pour l'espace utilisateur.

Ceci permet de configurer un système de telle sorte que différentes tâches indépendantes puissent partager des données du noyau, comme des pages des systèmes de fichiers, tout en isolant les allocations de l'espace utilisateur de chaque tâche dans leur cpuset. Pour ceci, il faut créer un gros cpuset hardwall qui contiendra toutes les tâches et créer des cpusets fils (non hardwall) pour chacune des tâches.

Seule une petite quantité de mémoire noyau, comme les demandes des gestionnaires d'interruption, peut être utilisée à l'extérieur d'un cpuset hardwall.

Notification à la libération¶

Si le drapeau notify_on_release d'un cpuset est activé (1), alors quand le dernier processus quitte le cpuset (il se termine ou s'attache à un autre cpuset) et que le dernier cpuset fils de ce cpuset a été supprimé, le noyau exécutera la commande /sbin/cpuset_release_agent en lui fournissant le chemin (relatif au point de montage du système de fichiers cpuset) du cpuset abandonné. Ceci permet de supprimer automatiquement les cpusets abandonnés.

Le drapeau notify_on_release du cpuset racine est désactivé (0) par défaut au moment du démarrage. La valeur par défaut pour les autres cpusets lors de leur création est égale à la valeur de notify_on_release de leur cpuset parent.

La commande /sbin/cpuset_release_agent est appelée, avec dans argv[1] le nom (un chemin relatif à /dev/cpuset) du cpuset à supprimer.

Le contenu habituel de la commande /sbin/cpuset_release_agent est simplement le script shell suivant :

#!/bin/sh
rmdir /dev/cpuset/$1

Comme pour les autres drapeaux ci-dessous, ce drapeau peut être modifié en écrivant un 0 ou un 1 ASCII (avec ou sans fin de ligne) dans le fichier pour respectivement désactiver ou activer le drapeau.

Pression mémoire¶

Le fichier memory_pressure d'un cpuset indique la moyenne instantanée du taux auquel les processus du cpuset tentent de libérer de la mémoire utilisée sur les nœuds du cpuset pour satisfaire les nouvelles demandes de mémoire.

Ceci permet à un gestionnaire de tâches de superviser les tâches qui s'exécutent dans des cpuset dédiés et détecter efficacement la pression mémoire qu'une tâche produit.

Ceci est utile à la fois pour les systèmes très surveillés qui exécutent diverses tâches qui leurs sont fournies et peuvent choisir de terminer ou de changer la priorité des tâches qui essaient d'utiliser plus de mémoire que les nœuds mémoire qui leurs ont été assignés leurs permettent, et les systèmes pour du calcul scientifique avec des tâches parallèles, fortement couplées, au temps d'exécution important, qui ne pourraient plus fournir les performances demandées si elles se mettaient à utiliser plus de mémoire qu'elles n'en ont droit.

Ce mécanisme fourni un moyen très économique pour détecter des signes de pression mémoire sur un cpuset. L'action à effectuer lorsqu'un signe de pression mémoire est détecté est laissé au libre arbitre du gestionnaire des tâches ou autre code utilisateur.

À moins que le calcul de la pression mémoire soit activé par le pseudofichier /dev/cpuset/cpuset.memory_pressure_enabled, cette pression mémoire n'est calculée pour aucun cpuset et les lectures dans les fichiers memory_pressure renvoient toujours zéro, c'est-à-dire la chaîne ASCII « 0\n ». Consultez la section AVERTISSEMENTS ci-dessous.

Une moyenne instantanée par cpuset est utilisée pour les raisons suivantes :

• Comme cette métrique est par cpuset plutôt que par processus ou par région mémoire virtuelle, la charge du système due à la supervision de cette métrique par un ordonnanceur de tâches est fortement réduite sur les gros systèmes, étant donné qu'il n'est pas nécessaire de parcourir la liste des tâches à chaque fois.
• Comme cette métrique est une moyenne instantanée plutôt qu'un compteur, un ordonnanceur de tâches obtient la pression mémoire en une seule lecture sans avoir à lire et se souvenir des résultats pendant un certain temps.
• Comme cette métrique est par cpuset plutôt que par processus, l'ordonnanceur de tâches peut obtenir l'information importante, la pression mémoire dans un cpuset, en une seule lecture sans nécessiter d'obtenir et de se souvenir des résultats pour tous les processus d'un cpuset (la liste des processus peut changer dynamiquement).

La pression mémoire d'un cpuset est calculée en utilisant un simple filtre digital par cpuset dans le noyau. Pour chaque cpuset, ce filtre suit le taux auquel les processus attachés à ce cpuset demandent au noyau de réutiliser de la mémoire.

Ces demandes de réutilisation de mémoire se produisent quand un processus doit satisfaire une demande de page mémoire en trouvant d'abord une page à réutiliser, du fait de l'absence de page disponible déjà prête. Les pages sales des systèmes de fichiers sont réutilisées en les écrivant d'abord sur le disque. Les tampons des systèmes de fichiers qui n'ont pas été modifiés sont réutilisés tout simplement en les abandonnant, mais si cette page est nécessaire de nouveau, il faudra la relire sur le disque.

Le fichier cpuset.memory_pressure fournit un nombre entier qui représente le taux des demandes récentes (la demi-vie est de 10 secondes) de réutilisation de mémoire par les processus du cpuset, l'unité étant le nombre de demandes par seconde fois 1000.

Répartition mémoire¶

Il y a deux fichiers, par cpuset, pour des drapeaux booléens qui contrôlent où le noyau alloue les pages pour les tampons des systèmes de fichiers et les structures de données liées internes au noyau. Ces fichiers sont cpuset.memory_spread_page et cpuset.memory_spread_slab.

Si le drapeau booléen cpuset.memory_spread_page est activé, alors le noyau répartit les tampons des systèmes de fichiers (les caches des pages) équitablement sur tous les nœuds autorisés pour le processus qui demande la page, au lieu de placer ces pages de préférence sur le nœud sur lequel s'exécute le processus.

Si le drapeau booléen cpuset.memory_spread_slab d'un cpuset est activé, alors le noyau répartira uniformément les caches slab liés aux systèmes de fichiers, comme ceux pour des entrées d'inœuds ou de répertoires, sur tous les nœuds autorisés pour le processus qui demande de la mémoire, plutôt que de préférer mettre ces pages sur le nœud sur lequel s'exécute le processus.

La configuration de ces drapeaux n'affecte pas les pages du segment de données (consultez brk(2)) ou du segment de la pile d'un processus.

Par défaut, les deux types de répartition de la mémoire sont désactivés et le noyau préfère allouer la mémoire sur le nœud local où s'exécute le processus. Si ce nœud n'est pas autorisé par la politique NUMA du processus ou par la configuration des cpusets ou s'il n'y a plus suffisamment de pages mémoire disponibles sur ce nœud, alors le noyau recherche le nœud le plus proche étant autorisé et ayant suffisamment de pages disponibles.

Quand un nouveau cpuset est créé, il hérite de la configuration de répartition mémoire de son père.

Activer la répartition mémoire a pour effet d'ignorer la politique mémoire NUMA du processus pour les allocations de pages ou de caches slab, qui sont alors éparpillées. Cependant, les changements dus à la répartition mémoire demandée par un cpuset ne sont pas visibles pour les appels système mbind(2) ou set_mempolicy(2). Ces deux appels système liés à la politique mémoire NUMA semblent se comporter comme si aucune répartition mémoire n'était demandée par un cpuset, même si c'est le cas. Si la répartition mémoire est par la suite désactivée pour les cpuset, la dernière politique mémoire NUMA définie par ces appels est automatiquement appliquée de nouveau.

cpuset.memory_spread_page et cpuset.memory_spread_slab sont tous les deux des fichiers contenant des drapeaux booléens. Par défaut, ils contiennent un « 0 », ce qui signifie que la fonctionnalité est désactivée pour ce cpuset. Si un « 1 » est écrit dans le fichier, la fonctionnalité correspondante est activée.

La répartition mémoire d'un cpuset se comporte de façon similaire à ce qui est connu (dans d'autres contextes) comme le placement mémoire à tour de rôle (« round-robin ») ou entrelacé (« interleave »).

La configuration d'une stratégie de répartition mémoire pour un cpuset peut améliorer significativement les performances pour les tâches qui :

• nécessitent de placer les données locales des threads dans des nœuds mémoire proches des CPU qui exécutent les threads qui accèdent le plus fréquemment à ces données ; mais aussi
• nécessitent d'accéder à de gros ensembles de données de systèmes de fichiers qui doivent être répartis sur différents nœuds du cpuset de la tâche du fait de leurs tailles.

Sans cette politique, la répartition des allocations mémoire sur les nœuds du cpuset de la tâche peut ne pas être équitable, particulièrement pour les tâches qui n'auraient qu'un thread chargé de l'initialisation ou de la lecture des données d'entrée.

Migration mémoire¶

Normalement, avec la configuration de cpuset.memory_migrate par défaut (désactivé), une fois qu'une page est allouée (une page physique de la mémoire lui est donnée), cette page reste sur le nœud où elle a été allouée, tant qu'elle reste allouée, même si la politique de placement mémoire du cpuset (mems) change par la suite.

Quand la migration mémoire est activée pour un cpuset, si la configuration de mems est modifiée alors toute page mémoire utilisée par un processus du cpuset qui se trouverait sur un nœud mémoire qui n'est plus autorisé sera déplacée sur un nœud mémoire qui est autorisé.

De plus, si un processus est déplacé dans un cpuset dont le drapeau memory_migrate est activé, toutes les pages mémoire qu'il utilise et qui se trouvent sur des nœuds mémoire qui étaient autorisés dans son cpuset précédant mais ne le sont plus dans le nouveau cpuset seront déplacées sur un nœud mémoire autorisé pour le nouveau cpuset.

L'emplacement relatif d'un page déplacée d'un cpuset est préservé si possible lors de ces opérations de déplacement. Par exemple, si la page se trouvait sur le deuxième nœud valable du précédent cpuset, alors la page sera placée sur le deuxième nœud valable du nouveau cpuset, si c'est possible.

Répartition de la charge par l'ordonnanceur¶

L'ordonnanceur du noyau répartit automatiquement la charge des processus. Si un CPU est sous-utilisé, le noyau recherchera des processus sur d'autres CPU plus chargés et déplacera ces processus sur le CPU sous-utilisé à condition que les mécanismes comme les cpuset et sched_setaffinity(2) le permettent.

Le coût de l'algorithme de répartition de la charge et son impact sur les structures de données partagées du noyau, comme la liste des processus, augmente plus que linéairement avec le nombre de CPU qui interviennent pour la répartition de la charge. Par exemple le coût pour la répartition de la charge dans un grand ensemble de CPU sera supérieur à celui pour la répartition de la charge dans deux ensembles ayant moitié moins de CPU. (La relation entre le nombre de CPU intervenant dans la répartition de la charge et le coût de cette répartition de charge dépend de l'implémentation de l'ordonnanceur de processus du noyau, qui change dans le temps quand de meilleurs algorithmes d'ordonnancement sont implémentés)

Le drapeau sched_load_balance d'un cpuset permet de supprimer cette répartition automatique de la charge dans les cas où elle n'est pas nécessaire et que sa suppression améliorerait les performances.

Par défaut, la répartition de la charge se fait sur tous les CPU, à l'exception de ceux marqués comme étant isolés en utilisant au moment du démarrage le paramètre du noyau « isolcpus= ». (Consultez la section Niveau du domaine de détente de l'ordonnanceur ci-dessous pour changer le comportement par défaut)

Cette répartition de la charge par défaut n'est pas bien adaptée aux situations suivantes :

• Sur les gros systèmes, la répartition de la charge sur beaucoup de CPU est très coûteuse. Si le système est géré avec des cpusets pour placer les tâches indépendantes sur différents ensembles de CPU, une répartition de la charge complète n'est pas nécessaire.
• Les systèmes avec une prise en charge temps-réel sur certains CPU doivent minimiser la surcharge du système sur ces CPU et donc éviter la répartition de la charge des processus si elle n'est pas nécessaire.

Quand le drapeau sched_load_balance d'un cpuset est activé (ce qui est le cas par défaut), une répartition de la charge sur tous les CPU autorisés par le cpuset est demandé, à condition que le processus puisse être déplacé d'un CPU du cpuset à un autre CPU (c'est-à-dire qu'il n'ait pas été attaché à des CPU avec, par exemple, sched_setaffinity(2)).

Quand le drapeau sched_load_balance d'un cpuset est désactivé, alors l'ordonnanceur évitera de déplacer des processus pour répartir la charge des CPU du cpuset, sauf si un autre cpuset partage le même CPU et a son drapeau sched_load_balance activé.

Ainsi, par exemple, si le cpuset racine a son drapeau sched_load_balance activé, alors l'ordonnanceur répartira la charge sur tous les CPU et la configuration du drapeau sched_load_balance des autres cpusets n'a pas d'effet, puisqu'une répartition complète de la charge est déjà demandée.

Dans les deux situations ci-dessus, le drapeau sched_load_balance devrait donc être désactivé sur le cpuset racine et seuls les cpusets fils plus petits devraient l'activer.

Lorsque vous faites ceci, vous ne devez généralement pas laisser un processus non attaché à un CPU dans le cpuset racine qui pourrait utiliser les CPU de façon non négligeable. De cette façon les processus peuvent être artificiellement contraints à un sous ensemble des CPU en fonction de la configuration de ce drapeau dans les cpusets descendants. Même si ce processus pourrait utiliser des cycles CPU inutilisés par certains CPU, l'ordonnanceur du noyau ne cherchera pas à répartir la charge du processus sur le CPU sous utilisé.

Bien sûr, les processus attachés à un CPU particulier peuvent être laissés dans un cpuset qui désactive sched_load_balance puisque ces processus ne peuvent être déplacés de toute façon.

Niveau du domaine de détente de l'ordonnanceur¶

L'ordonnanceur du noyau effectue une répartition de la charge immédiate lorsqu'un CPU devient disponible ou lorsqu'une autre tâche est prête. Cette répartition de la charge permet de s'assurer que le plus de CPU possibles sont utilisés efficacement en exécutant des tâches. Le noyau effectue aussi une répartition de la charge de façon plus sporadique sur la base de l'horloge logicielle décrite dans time(7). La configuration de sched_relax_domain_level ne s'applique qu'à la répartition de charge automatique. Indépendamment de la configuration de sched_relax_domain_level, une répartition de charge sporadique est effectuée à travers tous les CPU (sauf si cela a été désactivé avec sched_load_balance). Dans tous les cas, bien sûr, les tâches ne seront exécutées que sur les CPU autorisés par leur cpuset et par les appels systèmes sched_setaffinity(2).

Sur les petits systèmes, avec peu de CPU, la répartition de charge immédiate est utile pour améliorer l'interactivité du système et minimiser les cycles CPU inutilisés. Mais sur les gros systèmes, essayer de répartir la charge immédiatement sur un nombre important de CPU peut être plus coûteux que ce que ça ne rapporte, en fonction des performances des différentes tâches et du matériel.

La signification exacte des petites valeurs de sched_relax_domain_level dépendra de l'implémentation de l'ordonnanceur du noyau et de l'architecture non uniforme du matériel. Ces deux paramètres évolueront dans le temps et dépendent de l'architecture du système et de la version du noyau.

À ce jour, quand cette capacité a été introduite sous Linux 2.6.26, la signification des valeurs positives de sched_relax_domain_level est la suivante pour certaines des architectures les plus courantes :

1

Effectuer immédiatement une répartition de la charge sur les différents Hyper-Thread frères d'un même cœur.

2

Effectuer immédiatement une répartition de la charge sur les différents cœurs d'un processeur.

3

Effectuer immédiatement une répartition de la charge sur les différents CPU d'un même nœud ou d'une même lame.

4

Effectuer immédiatement une répartition de la charge sur les différents (détail d'implémentation) nœuds [pour les systèmes NUMA].

5

Effectuer immédiatement une répartition de la charge sur tous les CPU d'un système [pour les systèmes NUMA].

La valeur zéro (0) pour sched_relax_domain_level signifie toujours qu'il n'y a pas de répartition de charge immédiate, et donc la répartition de la charge s'effectue périodiquement et non pas immédiatement quand un CPU devient disponible ou qu'une tâche peut être exécutée.

La valeur -1 pour sched_relax_domain_level signifie toujours qu'il faut utiliser la valeur par défaut du système. La valeur par défaut du système peut varier en fonction de l'architecture et du noyau. Cette valeur par défaut du système peut être modifiée en fournissant au noyau un paramètre « relax_domain_level= » lors du démarrage.

Si des cpusets partagent des CPU et ont des valeurs de sched_relax_domain_level incompatibles, alors la valeur la plus élevée s'applique à tous les CPU de ces cpusets. Dans ce cas, -1 est la valeur la plus faible, remplacée par toute autre valeur et -0 est la valeur la plus faible suivante.

Affichage sous forme de masque¶

L'Affichage sous forme de masque est utilisé pour représenter les masques de bits des CPU et nœuds mémoire dans le fichier /proc/pid/status.

Ce format affiche chaque mot de 32 bits au format hexadécimal (en utilisant les caractères ASCII « 0 » - « 9 » et « a » - « f ») ; le début des mots est complété par des zéros si nécessaire. Pour les masques de plus d'un mot, une virgule est utilisée pour séparer les mots. Les mots sont affiché au format grand boutiste, avec le bit le plus significatif en premier. Les chiffres hexadécimaux d'un mot utilise aussi l'ordre grand boutiste.

Le nombre de mots de 32 bits affichés est le nombre minimal nécessaire pour afficher tous les bits du masque, en fonction de la taille du masque de bits.

Exemple d'Affichage sous forme de masque :

00000001                        # seul le bit 0
40000000,00000000,00000000      # seul le bit 94
00000001,00000000,00000000      # seul le bit 64
000000ff,00000000               # seuls les bits 32-39
00000000,000e3862               # les bits 1,5,6,11-13,17-19

Un masque avec les bits 0, 1, 2, 4, 8, 16, 32 et 64 activés sera affiché de cette façon :

00000001,00000001,00010117

Le premier « 1 » correspond au bit 64, le second au bit 32, le troisième au bit 16, le quatrième au bit 8, le cinquième au bit 4 et le « 7 » correspond aux bits 2, 1 et 0.

Affichage sous forme de liste¶

L'Affichage sous forme de liste pour les fichiers cpus et mems est une liste de numéros ou intervalles de CPU ou de nœuds mémoire séparés par des virgules, en décimal au format ASCII.

Exemple d'Affichage sous forme de liste :

0-4,9           # bits 0, 1, 2, 3, 4 et 9 activés
0-2,7,12-14     # bits 0, 1, 2, 7, 12, 13 et 14 activés

Activation de memory_pressure¶

Par défaut, le fichier cpuset.memory_pressure d'un cpuset vaut zéro (0). À moins que cette fonctionnalité soit activée en écrivant « 1 » dans le pseudofichier /dev/cpuset/cpuset.memory_pressure_enabled, le noyau ne calcule pas les valeurs des fichiers memory_pressure de chaque cpuset.

Utilisation de la commande echo¶

Lorsque la commande echo est utilisée dans un interpréteur de commandes pour changer les valeurs des fichiers d'un cpuset, soyez conscient que la commande echo interne à certains interpréteurs de commandes n'affiche pas de message d'erreur si l'appel système write(2) échoue. Par exemple, si la commande :

echo 19 > cpuset.mems

échoue parce que le nœud mémoire numéro 19 n'est pas autorisé (par exemple le système n'a pas de nœud mémoire numéro 19), alors la commande echo peut n'afficher aucune erreur. If faut mieux utiliser la commande externe /bin/echo pour changer la configuration d'un fichier d'un cpuset puisque cette commande affichera les erreurs de write(2), comme par exemple :

/bin/echo 19 > cpuset.mems
/bin/echo : erreur d'écriture : argument invalide

Placement mémoire¶

Les contraintes des cpusets ne s'appliquent pas à toutes les allocations de mémoire système pour les raisons suivantes :

Si la fonctionnalité de connexion à chaud est utilisée pour supprimer tous les CPU d'un cpuset, alors le noyau mettra à jour automatiquement la liste de CPU autorisés (cpus_allowed) de tous les processus attachés aux CPU du cpuset et autorisera tous les CPU. Le comportement est similaire lorsque la fonctionnalité de connexion à chaud est utilisée pour la mémoire. En général, le noyau préfère ne pas tenir compte du placement sur les CPU ou les nœuds mémoire plutôt que d'abandonner un processus dont tous les CPU ou nœuds mémoire autorisés sont déconnectés. Le code utilisateur devrait reconfigurer les cpusets pour ne mentionner que les CPU et les nœuds mémoire en ligne lorsque la fonctionnalité de connexion à chaud est utilisée pour ajouter ou retirer ces ressources.

Quelques demandes d'allocation mémoire critiques et internes au noyau, marquées GFP_ATOMIC, doivent être satisfaites immédiatement. Le noyau peut rater des demandes ou ne pas fonctionner correctement si certaines de ces allocations échouent. Si une de ces demandes ne peut être satisfaite par le cpuset du processus en cours, alors les contraintes du cpuset sont relâchées et le noyau recherche de la mémoire là où il peut en trouver. Il est préférable de ne pas respecter un cpuset plutôt que de stresser le noyau.

Les allocations de mémoire demandées par des pilotes du noyau lors du traitement d'une interruption ne se trouvent dans le contexte d'aucun processus et ne sont donc pas contraintes par les cpusets.

Renommer des cpusets¶

Vous pouvez utiliser l'appel système rename(2) pour renommer des cpusets. Seuls des renommages simples sont pris en charge ; c'est-à-dire que changer le nom du répertoire d'un cpuset est autorisé, mais déplacer le répertoire d'un cpuset dans un autre répertoire n'est pas autorisé.

Créer et s'attacher à un cpuset.¶

Voici les étapes pour créer un nouveau cpuset et lui attacher l'interpréteur de commandes en cours :

(1)

mkdir /dev/cpuset (si ce n'est déjà fait)

(2)

mount -t cpuset none /dev/cpuset (si ce n'est déjà fait)

(3)

Créer un nouveau cpuset avec mkdir(1).

(4)

Assigner des CPU et nœuds mémoire au nouveau cpuset.

(5)

Attacher l'interpréteur de commandes au nouveau cpuset.

Par exemple, la séquence de commandes suivante définira un cpuset appelé « Charlie », ne contenant que les CPU 2 et 3 et le nœud mémoire 1, et attachera l'interpréteur de commandes en cours à ce cpuset.

$ mkdir /dev/cpuset
$ mount -t cpuset cpuset /dev/cpuset
$ cd /dev/cpuset
$ mkdir Charlie
$ cd Charlie
$ /bin/echo 2-3 > cpuset.cpus
$ /bin/echo 1 > cpuset.mems
$ /bin/echo $$ > tasks
# Le shell en cours s'exécute désormais dans le cpuset Charlie
# La ligne suivante devrait afficher « /Charlie »
$ cat /proc/self/cpuset

Déplacer des tâches sur d'autres nœuds mémoire.¶

Pour déplacer les tâches attachées à un cpuset sur d'autres CPU et d'autres nœuds mémoire du système et déplacer les pages mémoires actuellement allouées par ces processus, effectuez les étapes suivantes :

(1)

Supposons qu'il faille déplacer les tâches du cpuset alpha (les CPU 4–7 et nœuds mémoire 2–3) vers un autre cpuset beta (CPU 16–19 et nœuds mémoire 8–9).

(2)

Créer d'abord le nouveau cpuset beta.

(3)

Autoriser les CPU 16–19 et les nœuds mémoire 8–9 pour beta.

(4)

Activer memory_migration dans beta.

(5)

Déplacer chaque tâche d'alpha vers beta.

La séquence de commandes suivante effectue cela.

$ cd /dev/cpuset
$ mkdir beta
$ cd beta
$ /bin/echo 16-19 > cpuset.cpus
$ /bin/echo 8-9 > cpuset.mems
$ /bin/echo 1 > cpuset.memory_migrate
$ while read i; do /bin/echo $i; done < ../alpha/tasks > tasks

La séquence ci-dessus déplace tous les processus de alpha vers beta et déplace toute mémoire utilisée par ces processus sur les nœuds mémoire 2–3 vers les nœuds mémoire 8–9.

Notez que la dernière étape de la séquence ci-dessus n'était pas :

$ cp ../alpha/tasks tasks

La boucle while, plutôt que l'utilisation de la commande cp(1), est nécessaire par ce qu'un seul identifiant de processus à la fois peut être écrit dans le fichier tasks.

La même chose (l'écriture d'un PID à la fois) peut se faire plus efficacement qu'avec la boucle while, en moins de caractère et dans une syntaxe qui fonctionne avec tous les interpréteurs de commandes mais malheureusement de façon moins intelligible, en utilisant l'option -u (sans tampon) de sed(1) :

$ sed -un p < ../alpha/tasks > tasks