Temps CPU
Le temps CPU (ou temps de traitement) est la durée pendant laquelle une unité centrale de traitement (CPU) est utilisée pour traiter les instructions d'un programme informatique ou d'un système d'exploitation, par opposition au temps écoulé, qui comprend par exemple l'attente d'une entrée/sortie (E/S) ou l'activation du mode à faible consommation («inactif»).
Le temps CPU est mesuré en tics d'horloge ou en secondes. Il est souvent utile de mesurer le temps CPU sous forme de pourcentage de la capacité du CPU, ce que l'on appelle l'utilisation du CPU. Le temps CPU et l'utilisation du CPU ont deux utilisations principales.
Le temps CPU est utilisé pour quantifier l'efficacité empirique globale de deux algorithmes fonctionnellement identiques. Par exemple, tout algorithme de tri prend une liste non triée et renvoie une liste triée, et le fera en un nombre déterministe d'étapes en fonction d'une liste d'entrée donnée.
En revanche, un tri à bulles et un tri par fusion ont une complexité de temps d'exécution différente, de sorte que le tri par fusion a tendance à se terminer en moins d'étapes. Sans aucune connaissance du fonctionnement de l'un ou l'autre algorithme, un temps CPU plus important pour le tri à bulles montre qu'il est moins efficace pour des données d'entrée particulières que le tri par fusion.
Ce type de mesure est particulièrement utile lors de la comparaison d'algorithmes similaires dont la complexité est non-négligeable. Dans ce cas, le temps réel de calcul (durée réelle écoulée) n'est pas vraiment pertinent, sachant que l'ordinateur peut exécuter le programme plus ou moins rapidement en fonction de variables telles que la température du processeur, ou le système d'exploitation (e.g. priorité du processus).
L'expression utilisation du processeur quantifie la façon dont le processeur est partagé entre les programmes informatiques.
Une utilisation élevée du processeur par un seul programme peut indiquer qu'il est très exigeant en puissance de traitement ou un dysfonctionnement ; par exemple, il est entré dans une boucle infinie. Le temps CPU permet de mesurer la puissance de traitement requise par un seul programme, éliminant les interférences, telles que le temps d'attente d'une entrée ou d'une suspension pour permettre à d'autres programmes de s'exécuter.
En revanche, le temps réel écoulé (ou simplement le temps réel ou le temps de l'horloge murale) est le temps écoulé entre le début d'un programme informatique et sa fin, mesuré par une horloge ordinaire. Le temps réel écoulé comprend le temps d'E/S, les retards multitâches et tous les autres types d'attente encourus par le programme.
Subdivision[modifier | modifier le code]
Le temps CPU ou l'utilisation du CPU peuvent être signalés pour chaque thread, pour chaque processus ou pour l'ensemble du système. De plus, selon ce que faisait exactement le CPU, les valeurs rapportées peuvent être subdivisées en :
- Le temps utilisateur est le temps pendant lequel le processeur est occupé à exécuter du code dans l'espace utilisateur.
- Le temps système est le temps pendant lequel le processeur a été occupé à exécuter du code dans l'espace du noyau. Si cette valeur est signalée pour un thread ou un processus, elle représente la durée pendant laquelle le noyau a travaillé dans un contexte d'exécution, par exemple, après qu'un thread a émis un appel système.
- Le temps d'inactivité (pour l'ensemble du système uniquement) correspond au temps pendant lequel le processeur n'a pas été occupé ou, à défaut, au temps pendant lequel il a exécuté le processus d'inactivité du système. Le temps d'inactivité mesure en fait la capacité inutilisée du processeur.
- Le temps de vol (pour l'ensemble du système uniquement), sur du matériel virtualisé, est la durée pendant laquelle le système d'exploitation a voulu s'exécuter, mais n'a pas été autorisé par l'hyperviseur[1]. Cela peut se produire si le matériel physique exécute plusieurs systèmes d'exploitation invités et que l'hyperviseur a choisi d'allouer un créneau horaire CPU à un autre.
Commandes Unix pour le temps CPU[modifier | modifier le code]
Haut de la commande Unix[modifier | modifier le code]
La commande Unix top fournit le temps CPU, la priorité, le temps réel écoulé et d'autres informations pour tous les processus et les met à jour en temps réel.
Temps de commande Unix[modifier | modifier le code]
La commande Unix time imprime le temps CPU et le temps réel écoulé pour un processus Unix:
% gcc nextPrimeNumber.c -o nextPrimeNumber
% time ./nextPrimeNumber 30000007
Prime number greater than 30000007 is 30000023
0.327u 0.010s 0:01.15 28.6% 0+0k 0+0io 0pf+0w
Ici, le processus prend un total de 0,337 seconde de temps CPU, dont 0,327 seconde est passée dans l'espace utilisateur et les 0,010 dernières secondes en mode noyau pour le compte du processus. Le temps réel écoulé est de 1,15 secondes. Voici le code source de l'application nextPrimeNumber, utilisée dans l'exemple ci-dessus.
// nextPrimeNumber.c
#include <stdio.h>
#include <stdlib.h>
int isPrimeNumber(unsigned long int n) {
for (int i = 2; i <= (n >> 1); ++i)
if (n % i == 0) return 0;
return 1;
}
int main(int argc, char *argv[]) {
unsigned long int argument = strtoul(argv[1], NULL, 10), n = argument;
while (!isPrimeNumber(++n));
printf("Prime number greater than %lu is %lu\n", argument, n);
return 0;
}
Fonctions POSIX clock() et getrusage()[modifier | modifier le code]
Les fonctions POSIX clock() et getrusage() peuvent être utilisées pour obtenir le temps CPU consommé par n'importe quel processus dans un environnement POSIX. Si le processus est multithread, le temps CPU est la somme de tous les threads.
Avec Linux à partir du noyau 2.6.26, il existe un paramètre RUSAGE_THREAD qui conduit à des statistiques d'utilisation des ressources pour le thread appelant uniquement.
Temps CPU total[modifier | modifier le code]
Sur les machines multiprocesseurs, un programme informatique peut utiliser deux processeurs ou plus pour le traitement à l'aide d'une planification de traitement parallèle. Dans de telles situations, on utilise la notion de temps CPU total, qui est la somme des temps CPU consommés par l'ensemble des CPU utilisés par le programme informatique.
Temps CPU et temps réel écoulé[modifier | modifier le code]
Le temps réel écoulé est toujours supérieur ou égal au temps CPU pour les programmes informatiques qui n'utilisent qu'un seul CPU pour le traitement. Si aucune attente n'est impliquée pour les E/S ou d'autres ressources, le temps réel écoulé et le temps CPU sont très similaires.
Temps CPU et temps réel écoulé pour la technologie de traitement parallèle[modifier | modifier le code]
Si un programme utilise le traitement parallèle, le temps CPU total pour ce programme est supérieur à son temps réel écoulé.
Le «(Temps CPU total)/(Nombre de CPU)» serait identique au temps réel écoulé si la charge de travail était uniformément répartie sur chaque CPU et qu'aucune attente n'était impliquée pour les E/S ou d'autres ressources.
Exemple : Une application logicielle exécutée sur un processeur hexa-cœur crée trois processus Unix pour répondre aux besoins de l'utilisateur. Chacun de ces trois processus crée deux threads, énumérant un total de 6 threads de travail. Le calcul est réparti équitablement sur les 6 threads indépendants. Si aucune attente de ressources n'est impliquée, le temps CPU total est en théorie égal à six fois le temps réel écoulé.
Notes et références[modifier | modifier le code]
- Ehrhardt, « CPU time accounting », IBM, (consulté le )
Voir aussi[modifier | modifier le code]
Articles connexes[modifier | modifier le code]
Liens externes[modifier | modifier le code]
- Chandra Thimmannagari, CPU Design: Answers to Frequently Asked Questions, Springer, (ISBN 0-387-23799-2, lire en ligne
), 68 - « Processor And CPU Time », The GNU C Library, (consulté le )
- « clock - report CPU time used », The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition (consulté le )
- « getrusage - get information about resource utilization », The Open Group Base Specifications Issue 6, IEEE Std 1003.1, 2004 Edition (consulté le )
