[ Note de l'éditeur :Il existe des limitations connues à l'épinglage du processeur dans certains environnements, alors assurez-vous de lire les détails de votre environnement avant de suivre ce didacticiel. ]
Les processeurs exécutent toutes les applications et il est préférable que vous compreniez comment cela fonctionne et comment vous pouvez ajuster l'utilisation du processeur pour augmenter les performances de vos applications.
Les systèmes modernes ont généralement plusieurs processeurs et cœurs, qui sont partagés entre tous les logiciels en cours d'exécution par le planificateur du noyau. Donc, normalement, vous ne vous souciez pas du processeur/cœur de votre application ou de votre processus, tant qu'il s'exécute.
Il existe plusieurs façons d'obtenir plus de CPU et d'améliorer le fonctionnement et l'efficacité de votre application. Une façon consiste à utiliser le réglage prioritaire en utilisant le nice /renice commande.
[ Vous pourriez également aimer : L'unité centrale de traitement (CPU) :ses composants et ses fonctionnalités ]
La deuxième méthode consiste à lier l'application à un ou plusieurs processeurs, ce que l'on appelle "CPU pinning" ou "CPU affinity". En liant l'application à un ou plusieurs processeurs spécifiques, tous les threads ou processus enfants liés à l'application s'exécutent sur des processeurs définis. De cette façon, limiter le processus/l'application à un ou plusieurs processeurs entraîne plus de "chaleur du cache" ou "d'accès au cache", augmentant ainsi les performances globales. Le premier avantage de l'affinité CPU est l'optimisation des performances du cache. Le deuxième avantage de l'affinité CPU est que si plusieurs threads accèdent aux mêmes données, il est logique de les exécuter tous sur le même processeur, ce qui nous aide à minimiser les échecs de cache.
Méthode 1 – Réglage des priorités
Changer la priorité du processus en utilisant un nice commande. C'est peut-être le moyen le plus connu d'améliorer l'utilisation du processeur des applications/processus.
Unix a toujours fourni un nice() appel système pour ajuster la priorité du processus, ce qui définit un bien-être valeur. Positif nice les valeurs entraînent une priorité de processus inférieure (plus agréable ), et les valeurs négatives (qui ne peuvent être définies que par le superutilisateur (root)) donnent une priorité plus élevée.
Le nice est toujours utile aujourd'hui pour ajuster la priorité des processus. Votre tâche consiste à identifier les travaux de faible priorité, qui peuvent inclure des agents de surveillance et des sauvegardes planifiées, que vous modifiez pour commencer par un nice valeur. Vous pouvez également effectuer une analyse pour vérifier que le réglage est efficace et que la latence du planificateur reste faible pour les travaux hautement prioritaires.
Comment ça marche ?
Chaque processus dispose d'un temps spécifique pour s'exécuter sur le processeur. Le temps réel pendant lequel le processus s'exécute sur le processeur est appelé le temps d'exécution virtuel du processus. Soit dit en passant, le processeur a tendance à agir comme un père et a l'habitude de diviser le temps de manière égale entre tous les enfants (les processus).
Le temps total qu'un processus passe "sur le CPU" est le temps d'exécution virtuel du processus. Le système d'exploitation (OS) conserve un enregistrement de cette exécution virtuelle et essaie d'accorder un temps égal à tous les processus de la file d'attente d'exécution.
Le nice et renice les utilitaires manipulent ce runtime virtuel.
Lorsque vous alimentez des valeurs positives avec renice /nice commandes, par exemple - renice +10 PID , vous ajoutez manuellement plus de runtime virtuel au processus. Le système d'exploitation pense que le processus a pris plus de temps d'exécution virtuel que les autres processus de la file d'attente d'exécution. Ainsi, au cycle suivant, le processeur accorde moins de temps au processus. Le processus se termine tard car il passe moins de temps "sur le processeur" maintenant, après le renice commande.
Mais lorsque vous alimentez des valeurs négatives avec renice /nice commandes, par exemple - renice -10 PID , vous réduisez manuellement la durée d'exécution virtuelle du processus. Le système d'exploitation pense que le processus n'a pas assez de temps "sur CPU" que les autres processus de la file d'attente d'exécution. Ainsi, lors du cycle suivant, le processeur accorde plus de temps "sur le processeur" à ce processus par rapport aux autres processus de la file d'attente d'exécution. Le processus se terminera rapidement.
Méthode 2 - processus de liaison
Un processus peut être lié à un ou plusieurs processeurs, ce qui peut augmenter ses performances en améliorant la chaleur du cache ou accès au cache et localité de la mémoire . Sous Linux, cela est effectué à l'aide du taskset commande, qui peut utiliser un masque CPU ou plages pour définir l'affinité CPU.
Utilisation de l'taskset , vous avez lié le processus 6197 pour qu'il ne s'exécute que sur le processeur 1. Cela entraînera plus de cache heat/cache hits. D'autres processus peuvent également s'exécuter sur le processeur 1, mais le processus ne s'exécute que sur le processeur 1 et le processeur 2. Cette configuration n'est pas permanente. Si le serveur redémarre ou si le processus est redémarré, le PID changera. Cette configuration est donc perdue.
Une meilleure façon est d'utiliser un fichier "drop-in".
Méthode 3 :Affinité CPU via un fichier d'insertion
Selon Wikipedia, Affinité du processeur , ou épingler le processeur ou "affinité de cache", permet la liaison et la dissociation d'un processus ou d'un thread à une unité centrale de traitement (CPU) ou à une plage de processeurs, de sorte que le processus ou le thread ne s'exécute que sur le ou les processeurs désignés plutôt que sur n'importe quel processeur .
Normalement, c'est le noyau qui détermine les processeurs qu'un processus exécute. Chaque fois que le planificateur replanifie un processus, il peut accéder à n'importe quel processeur disponible. Bien que cela convienne à la plupart des charges de travail, il est parfois souhaitable de limiter le ou les processeurs qu'un processus est autorisé à exécuter. Par exemple, limiter un processus gourmand en mémoire à seulement un ou deux processeurs augmente les chances d'un accès au cache, augmentant ainsi les performances globales.
Comment ça marche ?
Sur la photo, vous disposez de trois applications :X, Y et Z. Le comportement par défaut du planificateur consiste à utiliser tous les processeurs disponibles pour exécuter les threads des applications X, Y et Z. En utilisant les paramètres par défaut, vous pouvez voir que vous J'obtiendrai un bon nombre d'échecs de cache car l'application est répartie sur tous les processeurs. Ce qui entraîne moins d'accès au cache et plus d'échecs de cache.
Lorsque les applications sont épinglées à des processeurs spécifiques, elles sont obligées de s'exécuter sur des processeurs spécifiques, utilisant ainsi le cache du processeur plus efficacement :plus de code sur le même processeur. Cela se traduit par plus de cache warm/cache hits et donc une application plus performante.
Pour découvrir comment vous pouvez utiliser l'épinglage CPU/l'affinité CPU pour lier un processus à certains processeurs, épingler le sshd processus au CPU 0.
Vérifier l'état actuel de sshd un service. Vous vérifiez à quel processeur il se lie.
Selon le taskset pages de manuel de commande, valeur f signifie "n'importe quel processeur". Il n'y a donc pas d'épinglage ou de liaison CPU configuré pour sshd services.
Liez le sshd service au CPU 0 - création d'un drop-in fichier que vous utiliserez pour contrôler le comportement de sshd un service. Le fichier d'insertion contrôle de nombreux éléments liés à un processus, mais actuellement, vous vous limitez à l'épinglage/l'affinité du processeur.
Vous pouvez voir comment le taskset la commande affiche le processeur comme "1", ce qui, selon le taskset la page de manuel est le premier processeur disponible.
Vous pouvez en outre confirmer le fichier de dépôt en vérifiant l'état de sshd services.
Récapitulez
Vous pouvez utiliser soit nice ou renice pour modifier la priorité d'un processus. Les deux nice et renice les commandes peuvent manipuler le « runtime virtuel » du processus. Ainsi, en fonction des valeurs, le processus passe plus ou moins de temps sur le CPU.
Vous pouvez lier/épingler un processus à un ou plusieurs processeurs. Cela augmente les chances d'avoir plus de chaleur dans le cache/d'accès au cache, ce qui se traduit par de bien meilleures performances. Vous pouvez utiliser l'taskset outil de ligne de commande à cet effet. Mais l'effet n'est que temporaire. Si vous souhaitez que la configuration soit persistante, vous devez utiliser un fichier "drop-in".
[ Cours en ligne gratuit :Présentation technique de Red Hat Enterprise Linux. ]