Charge (calcul)

Dans le domaine informatique UNIX , la charge système est une mesure de la quantité de travail de calcul qu'un système informatique effectue. La charge moyenne représente la charge système moyenne sur une période donnée. Elle apparaît généralement sous la forme de trois nombres qui représentent la charge système au cours des dernières périodes d'une, cinq et quinze minutes.

Tous les systèmes Unix et similaires génèrent une mesure sans dimension de trois nombres de « charge moyenne » dans le noyau . Les utilisateurs peuvent facilement interroger le résultat actuel à partir d'un shell Unix en exécutant la uptimecommande :

uptime 14:34:03 up 10:43, 4 utilisateurs, charge moyenne : 0,06, 0,11, 0,09

Les commandes wet topaffichent les mêmes trois nombres de moyenne de charge, tout comme une gamme d' utilitaires d'interface utilisateur graphique .

Dans les systèmes d’exploitation basés sur le noyau Linux , ces informations sont facilement accessibles en lisant le /proc/loadavgfichier.

Pour explorer ce type d'informations en profondeur, conformément à la norme de hiérarchie du système de fichiers de Linux , les informations dépendantes de l'architecture sont exposées sur le fichier /proc/stat.

Un ordinateur inactif a un numéro de charge de 0 (le processus inactif n'est pas compté). Chaque processus utilisant ou attendant le processeur (la file d'attente prête ou la file d'attente d'exécution ) incrémente le numéro de charge de 1. Chaque processus qui se termine le décrémente de 1. La plupart des systèmes UNIX ne comptent que les processus en cours d'exécution (sur le processeur) ou exécutables (en attente du processeur) . Cependant, Linux inclut également les processus en état de veille ininterrompue (généralement en attente d' activité du disque ), ce qui peut conduire à des résultats sensiblement différents si de nombreux processus restent bloqués dans les E/S en raison d'un système d'E/S occupé ou bloqué. Cela inclut, par exemple, les processus bloqués en raison d'une panne de serveur NFS ou d'un support trop lent (par exemple, les périphériques de stockage USB 1.x). De telles circonstances peuvent entraîner une charge moyenne élevée, qui ne reflète pas une augmentation réelle de l'utilisation du processeur (mais donne néanmoins une idée du temps d'attente des utilisateurs).

Les systèmes calculent la charge moyenne comme la moyenne mobile exponentiellement amortie/pondérée du nombre de charges . Les trois valeurs de la charge moyenne se réfèrent aux dernières une, cinq et quinze minutes de fonctionnement du système.

Mathématiquement parlant, les trois valeurs représentent toujours la moyenne de toute la charge système depuis le démarrage du système. Elles décroissent toutes de manière exponentielle, mais à des vitesses différentes : elles décroissent de manière exponentielle de e après 1, 5 et 15 minutes respectivement. Par conséquent, la moyenne de charge sur 1 minute se compose de 63 % (plus précisément : 1 - 1/ e ) de la charge de la dernière minute et de 37 % (1/ e ) de la charge moyenne depuis le démarrage, à l'exclusion de la dernière minute. Pour les moyennes de charge sur 5 et 15 minutes, le même rapport 63 %/37 % est calculé sur 5 minutes et 15 minutes respectivement. Par conséquent, il n'est pas techniquement exact que la moyenne de charge sur 1 minute n'inclue que les 60 dernières secondes d'activité, car elle inclut 37 % de l'activité du passé, mais il est correct d'affirmer qu'elle inclut principalement la dernière minute.

Pour les systèmes monoprocesseurs , on peut considérer la charge moyenne comme une mesure de l'utilisation du système pendant la période concernée. Pour les systèmes dotés de plusieurs processeurs, il faut diviser la charge par le nombre de processeurs afin d'obtenir une mesure comparable .

Par exemple, on peut interpréter une charge moyenne de « 1,73 0,60 7,98 » sur un système monoprocesseur comme :

• Au cours de la dernière minute, le système a été surchargé de 73 % en moyenne (1,73 processus exécutables, de sorte que 0,73 processus ont dû attendre leur tour pour un système à un seul processeur en moyenne).
• Au cours des 5 dernières minutes, le processeur tournait au ralenti 40 % du temps, en moyenne.
• Au cours des 15 dernières minutes, le système a été surchargé de 698 % en moyenne (7,98 processus exécutables, de sorte que 6,98 processus ont dû attendre leur tour pour un système à un seul processeur en moyenne).

Cela signifie que ce système (CPU, disque, mémoire, etc.) aurait pu gérer tout le travail planifié pour la dernière minute s'il avait été 1,73 fois plus rapide.

Dans un système avec quatre processeurs, une charge moyenne de 3,73 indiquerait qu'il y avait, en moyenne, 3,73 processus prêts à s'exécuter, et chacun pourrait être planifié dans un processeur.

Sur les systèmes UNIX modernes, le traitement des threads par rapport aux moyennes de charge varie. Certains systèmes traitent les threads comme des processus aux fins du calcul de la moyenne de charge : chaque thread en attente d'exécution ajoutera 1 à la charge. Cependant, d'autres systèmes, en particulier les systèmes implémentant ce que l'on appelle le threading M:N , utilisent des stratégies différentes telles que compter le processus une seule fois aux fins de la charge (quel que soit le nombre de threads), ou compter uniquement les threads actuellement exposés par le planificateur de threads utilisateur au noyau, ce qui peut dépendre du niveau de concurrence défini sur le processus. Linux semble compter chaque thread séparément comme ajoutant 1 à la charge.

L'étude comparative de différents indices de charge réalisée par Ferrari et al. a montré que les informations sur la charge du processeur basées sur la longueur de la file d'attente du processeur sont bien plus efficaces en termes d'équilibrage de charge que l'utilisation du processeur. La raison pour laquelle la longueur de la file d'attente du processeur est meilleure est probablement que lorsqu'un hôte est fortement chargé, son utilisation du processeur est susceptible d'être proche de 100 %, et elle est incapable de refléter le niveau de charge exact de l'utilisation. En revanche, les longueurs de la file d'attente du processeur peuvent refléter directement la quantité de charge sur un processeur. À titre d'exemple, deux systèmes, l'un avec 3 et l'autre avec 6 processus dans la file d'attente, sont tous deux très susceptibles d'avoir des utilisations proches de 100 %, bien qu'elles diffèrent évidemment.

Sur les systèmes Linux, la charge moyenne n'est pas calculée à chaque tic d'horloge, mais est pilotée par une valeur variable basée sur le paramètre de fréquence HZ et testée à chaque tic d'horloge. Ce paramètre définit la fréquence de tic d'horloge du noyau en Hertz (fois par seconde) et sa valeur par défaut est de 100 pour des tic de 10 ms. Les activités du noyau utilisent ce nombre de tic pour se chronométrer. Plus précisément, la fonction timer.c::calc_load(), qui calcule la charge moyenne, s'exécute tous les tic LOAD_FREQ = (5*HZ+1) , soit environ toutes les cinq secondes :

avenrun [ 3 ] ;​
static inline void calc_load ( unsigned long ticks ) { unsigned long active_tasks ; /* virgule fixe */ static int count = LOAD_FREQ ;
count -= ticks ; if ( count < 0 ) { count += LOAD_FREQ ; active_tasks = count_active_tasks () ; CALC_LOAD ( avenrun [ 0 ], EXP_1 , tâches_actives ); CALC_LOAD ( avenrun [ 1 ], EXP_5 , tâches_actives ); CALC_LOAD ( avenrun [ 2 ], EXP_15 , tâches_actives ); } }

Le tableau avenrun contient des moyennes sur 1 minute, 5 minutes et 15 minutes. La CALC_LOADmacro et ses valeurs associées sont définies dans sched.h :

#define FSHIFT 11 /* nombre de bits de précision */ 
#define FIXED_1 (1<<FSHIFT) /* 1,0 en virgule fixe */ 
#define LOAD_FREQ (5*HZ+1) /* intervalles de 5 secondes */ 
#define EXP_1 1884 /* 1/exp(5sec/1min) en virgule fixe */ 
#define EXP_5 2014 /* 1/exp(5sec/5min) */ 
#define EXP_15 2037 /* 1/exp(5sec/15min) */
#define CALC_LOAD(charge,exp,n) \ 
 charge *= exp; \ 
 charge += n*(FIXED_1-exp); \ 
 charge >>= FSHIFT;

Le calcul « échantillonné » des moyennes de charge est un comportement assez courant ; FreeBSD, lui aussi, ne rafraîchit la valeur que toutes les cinq secondes. L'intervalle est généralement considéré comme imprécis afin de ne pas collecter les processus programmés pour se lancer à un moment précis.

Un article sur la liste de diffusion Linux considère que son tick +1 est insuffisant pour éviter les artefacts de moiré provenant d'une telle collecte, et suggère plutôt un intervalle de 4,61 secondes. Ce changement est courant parmi les noyaux de systèmes Android , bien que l'expression exacte utilisée suppose un HZ de 100.

D’autres commandes permettant d’évaluer les performances du système incluent :

• uptime – la fiabilité du système et la charge moyenne
• top – pour une vue d’ensemble du système
• vmstat – vmstat fournit des informations sur les processus exécutables ou bloqués, la mémoire, la pagination, les E/S de bloc, les interruptions et le processeur.
• htop – visualiseur de processus interactif
• dool(anciennement dstat), atop – permet de corréler toutes les données de ressources existantes pour les processus, la mémoire, la pagination, les E/S de bloc, les interruptions et l'activité du processeur.
• iftop – visualiseur interactif du trafic réseau par interface
• nethogs – visualiseur interactif du trafic réseau par processus
• iotop – visualiseur d’E/S interactif
• iostat – pour les statistiques d'E/S de stockage
• netstat – pour les statistiques du réseau
• mpstat – pour les statistiques du processeur
• tload – graphique de charge moyenne pour le terminal
• xload – graphique de charge moyenne pour X
• /proc/loadavg – fichier texte contenant la charge moyenne