Question Que signifient «réel», «utilisateur» et «sys» dans la sortie du temps (1)?


$ time foo
real        0m0.003s
user        0m0.000s
sys         0m0.004s
$

Que signifient «réel», «utilisateur» et «sys» dans la sortie du temps?

Lequel est significatif lors de l'analyse comparative de mon application?


1341
2018-02-17 11:33


origine


Réponses:


Statistiques de temps de traitement réel, utilisateur et système

Une de ces choses n'est pas comme les autres. Real fait référence au temps écoulé réel; L'utilisateur et le système font référence au temps CPU utilisé seulement par le processus.

  • Réal est l'heure de l'horloge murale - du début à la fin de l'appel. C'est tout le temps écoulé, y compris les tranches de temps utilisées par d'autres processus et le temps que le processus passe bloqué (par exemple s'il attend que les E / S soient terminées).

  • Utilisateur est la quantité de temps processeur passé en code en mode utilisateur (en dehors du noyau) dans le processus. Ce n'est que le temps CPU réel utilisé dans l'exécution du processus. Les autres processus et le temps que le processus passe bloqué ne comptent pas dans ce chiffre.

  • Sys est la quantité de temps CPU passé dans le noyau au sein du processus. Cela signifie l'exécution du temps CPU passé dans les appels système dans le noyau, par opposition au code de la bibliothèque, qui est toujours en cours d'exécution dans l'espace utilisateur. Comme 'user', c'est seulement le temps CPU utilisé par le processus. Voir ci-dessous pour une brève description du mode noyau (également appelé mode 'superviseur') et le mécanisme d'appel système.

User+Sys vous dira combien de temps processeur réel votre processus utilisé. Notez que cela concerne tous les processeurs, donc si le processus a plusieurs threads (et que ce processus est exécuté sur un ordinateur avec plusieurs processeurs), il pourrait potentiellement dépasser l'heure de l'horloge murale signalée par Real (ce qui se produit généralement). Notez que dans la sortie ces chiffres incluent le User et Sys temps de tous les processus de l'enfant (et de leurs descendants) aussi bien qu'ils auraient pu être collectés, par ex. par wait(2) ou waitpid(2), bien que les appels système sous-jacents renvoient les statistiques pour le processus et ses enfants séparément.

Origines des statistiques rapportées par time (1)

Les statistiques rapportées par time sont recueillies à partir de divers appels système. 'Utilisateur' et 'Sys' viennent de wait (2) ou times (2), en fonction du système particulier. 'Real' est calculé à partir d'une heure de début et de fin gettimeofday (2) appel. Selon la version du système, d'autres statistiques telles que le nombre de changements de contexte peuvent également être collectées par time.

Sur une machine multiprocesseur, un processus multi-thread ou un processus forking enfants peut avoir un temps écoulé inférieur au temps CPU total - que les threads différents ou les processus peuvent s'exécuter en parallèle. De plus, comme les statistiques de temps proviennent d'origines différentes, les temps enregistrés pour des tâches de très courte durée peuvent être sujets à des erreurs d'arrondi, comme le montre l'exemple donné par l'affiche originale.

Une brève introduction au mode noyau par rapport au mode utilisateur 

Sur Unix, ou n'importe quel système d'exploitation à mémoire protégée, «Noyau» ou «Superviseur» le mode se réfère à un mode privilégié que la CPU peut fonctionner. Certaines actions privilégiées qui pourraient affecter la sécurité ou la stabilité ne peuvent être effectuées que lorsque la CPU fonctionne dans ce mode; ces actions ne sont pas disponibles pour le code de l'application. Un exemple d'une telle action pourrait être la manipulation de MMU accéder à l'espace d'adressage d'un autre processus. Normalement, mode utilisateur le code ne peut pas le faire (avec raison), bien qu'il puisse demander la memoire partagée du noyau, qui pourrait être lu ou écrit par plus d'un processus. Dans ce cas, la mémoire partagée est explicitement demandée au noyau via un mécanisme sécurisé et les deux processus doivent s'y attacher explicitement pour pouvoir l'utiliser.

Le mode privilégié est généralement appelé mode 'noyau' car le noyau est exécuté par le processeur qui fonctionne dans ce mode. Pour passer en mode noyau, vous devez émettre une instruction spécifique (souvent appelée piège) qui fait passer le processeur à l'exécution en mode noyau et exécute le code à partir d'un emplacement spécifique conservé dans une table de saut.  Pour des raisons de sécurité, vous ne pouvez pas passer en mode noyau et exécuter du code arbitraire: les interruptions sont gérées via une table d'adresses qui ne peuvent être écrites que si le processeur fonctionne en mode superviseur. Vous piéger avec un numéro de piège explicite et l'adresse est recherchée dans la table de saut; le noyau a un nombre fini de points d'entrée contrôlés.

Les appels 'système' dans la bibliothèque C (en particulier ceux décrits dans la section 2 des pages de manuel) ont un composant en mode utilisateur, ce que vous appelez réellement de votre programme C. Dans les coulisses, ils peuvent émettre un ou plusieurs appels système au noyau pour effectuer des services spécifiques tels que les E / S, mais ils ont également du code en cours d'exécution en mode utilisateur. Il est également tout à fait possible d'émettre directement un piège en mode noyau à partir de n'importe quel code d'espace utilisateur, bien que vous ayez besoin d'écrire un extrait de langage d'assemblage pour configurer correctement les registres pour l'appel. Une page décrivant les appels système fournis par le noyau Linux et les conventions de configuration des registres peuvent être trouvées ici.

En savoir plus sur 'sys' 

Il y a des choses que votre code ne peut pas faire en mode utilisateur - des choses comme l'allocation de mémoire ou l'accès au matériel (disque dur, réseau, etc.). Ceux-ci sont sous la surveillance du noyau, et lui seul peut les faire. Certaines opérations que vous faites (comme malloc oufread/fwrite) invoquera ces fonctions du noyau et comptera alors comme temps 'sys'. Malheureusement, ce n'est pas aussi simple que "chaque appel à malloc sera compté à l'heure de" sys ". L'appel à malloc effectuera son propre traitement (toujours compté dans le temps 'user') et ensuite quelque part le long du chemin, il pourra appeler la fonction dans le noyau (comptée dans le temps 'sys'). Après le retour de l'appel du noyau, il y aura plus de temps dans 'user', puis malloc retournera à votre code. Quant à savoir quand le changement se produit, et combien il est dépensé en mode noyau ... vous ne pouvez pas le dire. Cela dépend de l'implémentation de la bibliothèque. En outre, d'autres fonctions apparemment innocentes pourraient également utiliser malloc et similaire dans le fond, qui aura encore du temps dans 'sys' alors.


1608
2018-04-29 05:29



Pour développer le réponse acceptée, Je voulais juste donner une autre raison real ≠ user + sys.

Garde en tête que real représente le temps écoulé réel, tandis que user et sys les valeurs représentent le temps d'exécution du processeur. En conséquence, sur un système multicœur, le user et / ou sys le temps (ainsi que leur somme) peut effectivement dépasser le temps réel. Par exemple, sur une application Java que je cours pour la classe, j'obtiens cet ensemble de valeurs:

real    1m47.363s
user    2m41.318s
sys     0m4.013s

213
2017-11-05 04:34



Real montre le temps total d'exécution pour un processus; tandis que l'utilisateur affiche le temps d'exécution pour les instructions définies par l'utilisateur et Sys est pour le temps pour l'exécution des appels système!

Le temps réel comprend également le temps d'attente (le temps d'attente pour les E / S, etc.)


14
2017-11-24 19:05



réal: Le temps réel passé à exécuter le processus du début à la fin, comme s'il avait été mesuré par un humain avec un chronomètre

utilisateur: Le temps cumulé passé par tous les processeurs lors du calcul

sys: Le temps cumulé passé par toutes les CPU lors de tâches liées au système telles que l'allocation de mémoire.

Notez que parfois l'utilisateur + sys peut être plus grand que réel, comme   plusieurs processeurs peuvent fonctionner en parallèle.


6