Les processus Linux peuvent avoir différentes priorités CPU et IO (nice et ionice).
Pourquoi y a-t-il un besoin d'avoir différentes priorités CPU et IO?
Y a-t-il une utilisation réelle pour les avoir différents?
Quels cas d'utilisation réels avez-vous trouvé nécessitant des priorités différentes en matière de CPU et d'E / S? Comme une priorité CPU supérieure à la normale mais inférieure à la priorité IO normale ou vice versa.
Le comportement par défaut de «nice» consiste à ajuster la priorité «io» de l'application également lorsque la gentillesse change.
Tout dépend bien sûr de votre charge de travail, mais l'un des aspects clés de tout système d'exploitation est de savoir comment il alloue ses ressources et comment il gère les conflits .
Il est en fait important de comprendre ce que fait la gentillesse, car lorsqu'il est sous la charge de processus concurrents, le comportement du système d'exploitation peut avoir un impact sur le reste de votre charge de travail.
La contention est la mesure de la manière dont différentes applications se font concurrence pour la même ressource (comme le processeur).
Charge de manutention
Depuis l'introduction de l'ordonnanceur complètement équitable, nice n'est qu'une interface avec la clause de «poids» de chaque processus. Qui peut être consulté dans proc.
$ cat /proc/self/sched
---------------------------------------------------------
...
se.load.weight : 1024
...
Changer la gentillesse modifie simplement le poids:
$ nice -n 5 cat /proc/self/sched
---------------------------------------------------------
...
se.load.weight : 335
...
La mesure de la contention du processeur est effectuée par l'algorithme de planification complètement équitable. Chaque application se voit attribuer une valeur de `` poids '' et dans le cas de temps CPU en conflit, le temps est divisé entre les processus en totalisant tous les traitements en compétition pour le temps CPU et en leur affectant le temps CPU de dénomination commune le plus bas en fonction de leur valeur de poids.
Si j'ai 3 applications qui souhaitent toutes utiliser le temps CPU, par défaut, elles reçoivent 1024 comme poids normal. Si j'ai un processus avec un joli +5 comme ci-dessus, les trois poids seraient totalisés à 2383, le processus niced recevrait ainsi environ 15% du temps de processeur en une seconde donnée si les 3 processus demandaient le CPU dans cette seconde .
Pourquoi y a-t-il un besoin d'avoir différentes priorités CPU et IO?
La gentillesse ne joue vraiment que sur ce qu'il faut faire lorsque le système est sous charge, c'est-à-dire comment le système d'exploitation réduit le temps entre les processus concurrents tels que définis par les facteurs nécessaires.
La manière dont cela vous affecte ou vous concerne est liée aux priorités de livraison que les différentes applications ont entre elles et au délai de livraison de chaque application.
La gentillesse ne fait vraiment quelque chose que lorsque votre système est sous charge (il y a plus de choses qui demandent de l'attention que le processeur ou le disque ne peut en gérer). Il indique simplement au noyau comment allouer des ressources dans ces circonstances.
Y a-t-il une utilisation réelle pour les avoir différents?
Si vous avez de nombreux processus concurrents ou du travail à faire qui est plus que ce que peut faire le CPU, la gentillesse vous donne des garanties relativement stables quant au travail qui se termine en premier. Cela peut être important pour vous si vous dites que vous produisez un rapport qui doit être remis avant la fin d'un autre rapport.
Sur un système de bureau, la gentillesse peut être encore plus importante. Certaines applications ont un comportement en temps réel grâce auquel elles se réveillent plus souvent pendant le chargement empêchent les données de devenir périmées. Pulseaudio entre par exemple dans cette catégorie.
D'autres applications peuvent être nécessaires pour répartir le travail pour les applications dépendantes. Par exemple, beaucoup de requêtes Apache pour dire qu'un serveur SQL comme MySQL peut bloquer pendant une longue période car SQL ne sert pas assez rapidement parce que - disons qu'un autre rapport est en compétition pour le temps CPU. Donc, non seulement SQL est bloqué, mais Apache aussi. SQL peut parfois faire mal ici, car il y a généralement beaucoup moins de threads de travail que les threads Apache en compétition en tant que groupe pour être pesé plus favorablement par le planificateur, ce qui donne plus de temps CPU à SQL.
UpdateDB (un programme qui indexe les fichiers) s'exécute tard dans la nuit et est très lourd sur le disque. Il peut être utile de réduire sa priorité de planification d'E / S afin que les autres applications à ce moment-là obtiennent la priorité sur quelque chose qui n'est pas aussi important dans l'ordre des choses.
Quels cas d'utilisation réels avez-vous trouvé nécessitant des priorités différentes en matière de CPU et d'E / S?
Très peu. La gentillesse est trop une approche du meilleur effort. En règle générale, je me soucie moins sur la façon dont les performances des applications et plus sur quel point ils pourraient effectuer. Cela peut sembler rétrograde au début, mais j'ai des garanties de prestation de services à respecter qui sont plus importantes pour moi.
Je veux que la confiance me dise que "vos trucs même un mauvais jour seront faits dans la période X". Si ça va plus vite, c'est juste un bonus.
Je commencerai généralement par générer des spécifications convenues telles que:
Et dessinez des exigences pour répondre comme:
Si les spécifications sont vraies, j'atteins ces objectifs sans faire de virtualisation, en utilisant l'approche beaucoup plus efficace des groupes de contrôle.
Les groupes de contrôle me permettent de garantir des niveaux de service assez fiables pour l'allocation des ressources à condition que l'application se comporte dans les limites spécifiées. Cela signifie que même sur un système sous charge, je peux garantir la disponibilité des ressources pour l'application en question et garantir de l'espace pour d'autres applications sur le même boîtier!
Si nous prenons votre exemple de CPU et d'E / S. J'ai mis en place des limites qui répondent à ces exigences:
# cd /sys/fs/cgroup/blkio/apache
# echo "253:0 100" >blkio.throttle.read_iops_device
# echo "253:0 50" >blkio.throttle.write_iops_device
# echo "253:0 102400" >blkio.throttle.read_bps_device
Donc 100k octets pour lire 100 iops.
# cd /sys/fs/cgroup/cpu/apache
# echo 1000000 >cpu.cfs_period_us
# echo 60000 >cpu.cfs_quota_us
Sur une période de 1 seconde, donnez 0,06 seconde de CPU.
# cd /sys/fs/cgroup/cpu/sql
# echo 1000000 >cpu.cfs_period_us
# echo 20000 >cpu.cfs_quota_us
Sur une période de 1 seconde, donnez 0,02 seconde de CPU.
Fournir d'autres groupes de contrôle concurrents ne fait rien de stupide, être sous charge est moins un facteur dans ma prestation de services parce que je sais comment le CPU est lancé pour chaque application.
Les groupes de contrôle de cette nature sont toujours les meilleurs efforts, mais ils offrent beaucoup plus de contrôle sur cet effort que la gentillesse et l'ionicité.