Ce n' 'réel', 'utilisateur' et 'sys' signifie en sortie de temps(1)?

Réel, l'Utilisateur et les Sys processus de statistiques en temps

L'une de ces choses n'est pas comme les autres. Réel se réfère à la durée réelle; l'Utilisateur et Sys reportez-vous à temps CPU utilisé seulement par le processus.

• Réel est l'horloge du mur de temps en temps à partir de début à la fin de l'appel. C'est tout ce temps écoulé, y compris les tranches de temps utilisé par d'autres processus et le temps que le processus de passe bloqué (par exemple si elle est en attente d'e/S à compléter).

• Utilisateur est la quantité de temps CPU passé en mode code (à l'extérieur du noyau) dans le processus. Ce n'est réel le temps CPU utilisé dans l'exécution du processus. D'autres processus et le temps du processus de passe bloqués ne sont pas pris en compte dans cette figure.

• Sys est la quantité de temps CPU passé dans le noyau dans le processus. Cela signifie que l'exécution de l'UC le temps passé dans le système des appels dans le noyau, par opposition à la bibliothèque de code, qui est toujours en cours d'exécution dans l'espace utilisateur. Comme "utilisateur", ce n'est que le temps CPU utilisé par le processus. Voir ci-dessous, une brève description du mode noyau (également connu en tant que "superviseur" en mode) et le système de mécanisme d'appel.

User+Sys vous indiquera la quantité réelle de temps CPU de votre processus utilisé. Notez que ceci est le cas pour tous les Processeurs, donc, si le processus a plusieurs threads (et ce processus est en cours d'exécution sur un ordinateur avec plus d'un processeur), il pourrait éventuellement dépasser le mur de l'horloge temps indiqué par Real (ce qui se produit généralement). Notez que dans la production, ces chiffres comprennent les User et Sys le temps de tous les processus enfants (et leurs descendants) et quand ils ont pu être collectées, par exemple, par wait(2) ou waitpid(2), bien que le système sous-jacent, les appels de retour de la statistique du processus et de ses enfants séparément.

Origines de la statistique rapporté par time (1)

Les statistiques fournies par time sont recueillies auprès de divers appels système. 'Utilisateur' et 'Sys' proviennent wait (2) (POSIX) ou fois (2) (POSIX), selon le système particulier. "Réel" est calculé à partir d'un début et heure de fin recueillies à partir de l' gettimeofday (2) appel. Selon la version du système, diverses autres statistiques telles que le nombre de changements de contexte peuvent aussi être recueillies par time.

Sur une machine multi-processeur, un processus multithread ou un processus de bifurcation des enfants peuvent avoir un temps écoulé plus petit que le CPU total temps que les différents threads ou processus peuvent s'exécuter en parallèle. Aussi, le temps de statistiques proviennent de différentes origines, tant de fois enregistré pour de très courtes tâches en cours d'exécution peut être sujet à des erreurs d'arrondi, comme l'exemple donné par le posteur d'origine montre.

Une brève introduction sur le Noyau vs mode Utilisateur

Sur Unix, ou tout protégé de la mémoire du système d'exploitation, 'Noyau" ou "Superviseur" mode se réfère à un mode privilégié que le PROCESSEUR peut fonctionner dans. Certain nombre d'actions privilégiées qui pourraient affecter la sécurité ou la stabilité ne peut être effectuée que lorsque le CPU est en fonctionnement 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 la MMU pour accéder à l'espace d'adressage d'un autre processus. Normalement, en mode utilisateur code ne peut pas le faire (avec raison), mais il peut demander de mémoire partagée à partir du noyau, qui pourrait être lus ou écrits par plus d'un processus. Dans ce cas, la mémoire partagée est explicitement demandé au noyau par l'intermédiaire d'un mécanisme sécurisé, et les deux procédés ont explicitement joindre à elle afin de l'utiliser.

Le mode privilégié est généralement dénommé "noyau" mode parce que le noyau est exécuté par le PROCESSEUR de fonctionner dans ce mode. Pour passer en mode noyau, vous devez émettre une instruction spécifique (souvent appelé un piège) que les commutateurs de la CPU à l'exécution en mode noyau et exécute le code à partir d'un emplacement tenue à un saut de la table. Pour des raisons de sécurité, vous ne pouvez pas passer en mode noyau et d'exécuter du code arbitraire - les pièges sont gérées au moyen d'une table d'adresses qui ne peut pas être écrite, à moins que le PROCESSEUR fonctionne en mode superviseur. Vous piège explicitement avec un numéro d'interruption, et l'adresse est recherché dans le saut de la table; le noyau a un nombre fini de contrôlé les points d'entrée.

Le "système" des appels à la bibliothèque C (en particulier ceux décrits dans la Section 2 de l'homme pages) ont un composant en mode utilisateur, ce qui est exactement ce que vous appelez à partir de votre programme C. En coulisses, ils peuvent émettre une ou plusieurs appels système au noyau de faire des services spécifiques tels que les I/O, mais encore, ils ont aussi le code s'exécutant en mode utilisateur. Il est tout à fait possible d'attribuer un piège pour le mode noyau à partir de n'importe quel utilisateur de l'espace de code si vous le souhaitez, même si vous pouvez avoir besoin d'écrire un extrait de l'assemblée de la langue pour configurer les registres correctement pour l'appel.

Plus sur "sys"

Il y a des choses que votre code ne peut pas le faire depuis le mode utilisateur - des choses comme l'allocation de la mémoire ou de l'accès au matériel (disque dur, réseau, etc.). Ces derniers sont sous la supervision du noyau, et lui seul peut le faire. Certaines opérations comme malloc oufread/fwrite appelle ces fonctions du noyau et qui, ensuite, sera considéré comme " sys " de temps. Malheureusement, il n'est pas aussi simple que "tous les appels à malloc sera compté dans" sys "temps". L'appel à malloc va faire du traitement de ses propres (compte toujours dans "utilisateur" ou " le temps) et puis, quelque part le long de la manière dont elle peut faire appel à la fonction dans le noyau (compté dans 'sys' époque). Après son retour à partir du noyau d'appel, il y aura un peu plus de temps dans "l'utilisateur" et ensuite malloc sera de retour à votre code. Comme lorsque le commutateur qui se passe, et combien il est passé en mode noyau... on ne peut pas dire. Il dépend de l'implémentation de la bibliothèque. Aussi, d'autres apparemment innocent fonctions peuvent également utiliser malloc et la comme dans le fond, qui sera de nouveau un peu de temps dans " sys " puis.

• réel: Le temps réel passé à l'exécution de ce processus du début à la fin, comme si elle a été mesurée par un homme avec un chronomètre

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

• sys: Le temps cumulé passé par tous les Processeurs au cours de système liés à des tâches telles que l'allocation de mémoire.

Remarquer que parfois user + sys peut-être plus que réelle, comme
plusieurs processeurs peuvent travailler en parallèle.

Minimum praticable POSIX C exemples

Pour rendre les choses plus concrètes, je veux illustrer quelques cas extrêmes de time, avec un minimum de C des programmes de test.

Tous les programmes peut être compilé et exécuté avec:

gcc -ggdb3 -o main.out -pthread -std=c99 -pedantic-errors -Wall -Wextra main.c
time ./main.out

et ont été testés sous Ubuntu 18.10, GCC 8.2.0, glibc 2.28, le noyau Linux 4.18, ThinkPad P51 ordinateur portable, Intel Core i7-7820HQ CPU (4 coeurs /8 threads), 2x Samsung M471A2K43BB1-CRC de RAM (2x 16GiB).

sommeil

Non-occupé sommeil ne compte pas dans user ou sys, seulement real.

Par exemple, un programme qui dort pendant une seconde:

#define _XOPEN_SOURCE 700
#include <stdlib.h>
#include <unistd.h>

int main(void) {
    sleep(1);
    return EXIT_SUCCESS;
}

GitHub en amont.

sorties quelque chose comme:

real    0m1.003s
user    0m0.001s
sys     0m0.003s

La même chose vaut pour les programmes bloqués sur IO devient disponible.

Par exemple, le programme attend que l'utilisateur entre un caractère et appuyez sur entrée:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    printf("%c\n", getchar());
    return EXIT_SUCCESS;
}

GitHub en amont.

Et si vous attendez environ une seconde, il sort tout comme le sommeil exemple quelque chose comme:

real    0m1.003s
user    0m0.001s
sys     0m0.003s

Plusieurs threads

L'exemple suivant ne niters itérations inutiles CPU lourds travaux sur nthreads threads:

#define _XOPEN_SOURCE 700
#include <assert.h>
#include <inttypes.h>
#include <pthread.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

uint64_t niters;

void* my_thread(void *arg) {
    uint64_t *argument, i, result;
    argument = (uint64_t *)arg;
    result = *argument;
    for (i = 0; i < niters; ++i) {
        result = (result * result) - (3 * result) + 1;
    }
    *argument = result;
    return NULL;
}

int main(int argc, char **argv) {
    size_t nthreads;
    pthread_t *threads;
    uint64_t rc, i, *thread_args;

    /* CLI args. */
    if (argc > 1) {
        niters = strtoll(argv[1], NULL, 0);
    } else {
        niters = 1000000000;
    }
    if (argc > 2) {
        nthreads = strtoll(argv[2], NULL, 0);
    } else {
        nthreads = 1;
    }
    threads = malloc(nthreads * sizeof(*threads));
    thread_args = malloc(nthreads * sizeof(*thread_args));

    /* Create all threads */
    for (i = 0; i < nthreads; ++i) {
        thread_args[i] = i;
        rc = pthread_create(
            &threads[i],
            NULL,
            my_thread,
            (void*)&thread_args[i]
        );
        assert(rc == 0);
    }

    /* Wait for all threads to complete */
    for (i = 0; i < nthreads; ++i) {
        rc = pthread_join(threads[i], NULL);
        assert(rc == 0);
        printf("%" PRIu64 " %" PRIu64 "\n", i, thread_args[i]);
    }

    free(threads);
    free(thread_args);
    return EXIT_SUCCESS;
}

GitHub en amont + terrain de code.

Puis nous avons tracé du mur, de l'utilisateur et sys en tant que fonction du nombre de threads pour un fixe de 10^10 itérations sur mes 8 hyperthread CPU:

Parcelle de données.

À partir du graphique, nous voyons que:

• pour un CPU simple coeur de l'application, le mur et l'utilisateur sont sur la même

• pour 2 cœurs, l'utilisateur est environ 2x mur, ce qui signifie que l'utilisateur le temps est compté à travers tous les threads.

  utilisateur fondamentalement doublé, et tout mur est resté le même.

• cela continue jusqu'à 8 threads, ce qui correspond à mon numéro de hyperthreads dans mon ordinateur.

  Après le 8, le mur commence à augmenter, parce que nous n'avons pas extra Cpu pour mettre plus de travail dans un laps de temps donné!

  Le ratio des plateaux à ce point.

Sys lourds travaux avec sendfile

Le plus lourd sys de la charge de travail que je pouvais venir a été d'utiliser la sendfile, qui fait une opération de copie de fichier sur l'espace noyau: Copier un fichier dans un esprit sain, sûr et efficace

Donc j'ai imaginé que ce noyau memcpy sera un CPU de fonctionnement intensif.

J'ai d'abord initialiser un grand 10GiB de fichier aléatoire avec:

dd if=/dev/urandom of=sendfile.in.tmp bs=1K count=10M

Puis exécutez le code:

#define _GNU_SOURCE
#include <assert.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/sendfile.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main(int argc, char **argv) {
    char *source_path, *dest_path;
    int source, dest;
    struct stat stat_source;
    if (argc > 1) {
        source_path = argv[1];
    } else {
        source_path = "sendfile.in.tmp";
    }
    if (argc > 2) {
        dest_path = argv[2];
    } else {
        dest_path = "sendfile.out.tmp";
    }
    source = open(source_path, O_RDONLY);
    assert(source != -1);
    dest = open(dest_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    assert(dest != -1);
    assert(fstat(source, &stat_source) != -1);
    assert(sendfile(dest, source, 0, stat_source.st_size) != -1);
    assert(close(source) != -1);
    assert(close(dest) != -1);
    return EXIT_SUCCESS;
}

GitHub en amont.

qui donne essentiellement la plupart de système de temps que prévu:

real    0m2.175s
user    0m0.001s
sys     0m1.476s

J'étais également curieux de voir si time permettraient de faire la distinction entre les appels des différents processus, j'ai donc essayé:

time ./sendfile.out sendfile.in1.tmp sendfile.out1.tmp &
time ./sendfile.out sendfile.in2.tmp sendfile.out2.tmp &

Et le résultat a été:

real    0m3.651s
user    0m0.000s
sys     0m1.516s

real    0m4.948s
user    0m0.000s
sys     0m1.562s

Le sys fois est approximativement la même pour les deux pour un seul processus, mais le mur de temps est plus grande parce que les processus sont en compétition pour le disque de l'accès en lecture probable.

Il semble donc qu'il ne fait en compte pour le processus qui a commencé un travail sur le noyau.

Bash code source

Lorsque vous faites juste time <cmd> sur Ubuntu, utilisez le Bash mot-clé peut être vu à partir de:

type time

sorties:

time is a shell keyword

Nous avons donc grep source dans le Bash 4.19 code source de la chaîne de sortie:

git grep '"user\b'

qui nous conduit à execute_cmd.c fonction time_command, qui utilise:

• gettimeofday() et getrusage() si les deux sont disponibles
• times() sinon

qui sont tous des Les appels système Linux et Les fonctions POSIX.

GNU Coreutils code source

Si nous l'appelons comme:

/usr/bin/time

puis il utilise GNU Coreutils mise en œuvre.

Celui-ci est un peu plus complexe, mais la source semble être à resuse.c et il n':

• un non-POSIX BSD wait3 appel, si c'est disponible
• times et gettimeofday sinon