Comment mesurer le temps cpu et de temps horloge murale?

J'ai vu de nombreux sujets sur ce sujet, même sur stackoverflow, par exemple:

Comment puis-je mesurer le temps CPU et de la paroi de l'horloge temps sur Linux/Windows?

Je veux mesurer à la fois le cpu et le mur du temps. Bien que la personne qui a répondu à une question dans le sujet que j'ai posté vous recommandons d'utiliser gettimeofday pour mesurer un mur de temps, j'ai lu qu'il est préférable de l'utiliser à la place clock_gettime. Alors, j'ai écrit le code ci-dessous (c'est ok, est-il vraiment un mur le temps, pas le temps cpu? Im poser, parce que j'ai trouvé une page web: http://nadeausoftware.com/articles/2012/03/c_c_tip_how_measure_cpu_time_benchmarking#clockgettme où il est dit que clock_gettime mesures de temps de cpu...) Ce qui est la vérité et qui dois-je utiliser pour mesurer un mur de temps?

Une autre question est au sujet de temps cpu. J'ai trouvé la réponse que clock est grande à ce sujet, j'ai donc écrit un exemple de code pour ça aussi. Mais ce n'est pas ce que je veux vraiment, pour mon code, il me montre un 0 secods de temps cpu. Est-il possible de mesurer le temps cpu de manière plus précise (en secondes)? Merci pour toute aide (pour le moment, Im uniquement intéressés par des solutions Linux).

Voilà mon code:

#include <time.h>
#include <stdio.h>      /* printf */
#include <math.h>       /* sqrt */
#include <stdlib.h>

int main()
{
    int i;
    double sum;

    //measure elapsed wall time
    struct timespec now, tmstart;
    clock_gettime(CLOCK_REALTIME, &tmstart);
    for(i=0; i<1024; i++){
        sum += log((double)i);
    }
    clock_gettime(CLOCK_REALTIME, &now);
    double seconds = (double)((now.tv_sec+now.tv_nsec*1e-9) - (double)(tmstart.tv_sec+tmstart.tv_nsec*1e-9));
    printf("wall time %fs\n", seconds);

    //measure cpu time
    double start = (double)clock() /(double) CLOCKS_PER_SEC;
    for(i=0; i<1024; i++){
        sum += log((double)i);
    }
    double end = (double)clock() / (double) CLOCKS_PER_SEC;
    printf("cpu time %fs\n", end - start);

    return 0;
}

Le compiler comme ceci:

gcc test.c -o test -lrt-lm

et il me montre:

wall time 0.000424s
cpu time 0.000000s

Je sais que je peux faire plus d'itérations, mais ce n'est pas le point ici 😉

IMPORTANT: 

printf("CLOCKS_PER_SEC is %ld\n", CLOCKS_PER_SEC);

montre 

CLOCKS_PER_SEC is 1000000
Utilisation du générateur de profils...
Je souhaite que je pourrais, mais j'ai besoin de le faire moi même 🙂
Peut-être que si vous n'étiez pas en divisant le résultat de la clock() fonction par CLOCKS_PER_SEC votre résolution serait mieux qu'une seconde, la grh?
ce qui se passe quand vous prenez un numéro et de le diviser par un autre, est-il obtenir le plus précis ou le moins? Plus facile question: fait-il plus grand ou plus petit? Oui, le site vous lien ne la division dans son exemple, mais il tombe sur vous pour comprendre le raisonnement, et sans doute, pour quelque raison que ce n'est pas pour l'amélioration de la résolution. Comme pour "corriger de temps processeur pour assurer" -- si l'horloge() est de retour correct de temps cpu, puis par ne le modifie pas, bien sûr. Ne JAMAIS taper dans le code que vous trouverez dans un endroit aléatoire sans réfléchir ce qu'il fait réellement en premier.
"Ce qui est la vérité et qui dois-je utiliser pour mesurer un mur de temps?" - Le fait est qu'il y a des beaucoup différentes façons de mesurer le mur du temps. Certaines sont plus précises que d'autres. Certains sont plus mobiles que d'autres. À vous de choisir et d'utiliser tout ce qui convient à votre fantaisie. Ma réponse sur la question que vous avez lié utilise gettimeofday() parce que c'était la première chose qui fonctionnait assez bien pour moi.

OriginalL'auteur Brian Brown | 2013-07-06

  1. 6

    Selon ma page de manuel sur clock il dit

    POSIX exige que CLOCKS_PER_SEC est égal à 1000000 indépendante de la résolution.

    Lors de l'augmentation du nombre d'itérations sur mon ordinateur mesurées cpu-temps commence à se montrer sur 100000 itérations. Depuis le retour de chiffres, il semble que la résolution est en réalité de 10 millisecondes.

    Méfiez-vous que lorsque vous optimisez votre code, la totalité de la boucle peut disparaître parce que sum est morte de la valeur. Il n'y a rien pour arrêter le compilateur de déplacement de la clock états à travers la boucle, comme il n'existe pas de réelle dépendance avec le code entre les deux.

    Permettez-moi de développer un peu plus sur le micro des mesures de la performance du code. Les naïfs et tentant manière de mesurer la performance est en effet par l'ajout de clock déclarations comme vous l'avez fait. Cependant, puisque le temps n'est pas un concept ou d'effet secondaire en C, les compilateurs peuvent souvent passer ces clock les appels à volonté. Pour remédier à cela, il est tentant de faire de telles clock appels ont des effets secondaires, comme par exemple, avoir accès volatile variables. Cependant ce n'est toujours pas interdire le compilateur de se déplacer très sans effets secondaires code sur les appels. Pensez par exemple à l'accès régulier des variables locales. Mais pire encore, en faisant de la clock appels look très effrayant pour le compilateur, vous allez effectivement avoir un impact négatif de toutes les optimisations. En conséquence, la simple mesure de l'impact sur les performances, le rendement dans un négatif et indésirables.

    Si vous utilisez le profilage, comme déjà mentionné par quelqu'un, vous pouvez obtenir une assez bonne évaluation de la performance du même code optimisé, bien que le temps de parcours est augmenté.

    Une autre bonne façon de mesurer le rendement est en train de demander au compilateur de déclarer le nombre de cycles de code à prendre. Pour beaucoup d'architectures le compilateur a une très grande précision d'estimation de cette. Cependant, la plupart des notamment pour un Pentium l'architecture ce n'est pas parce que le matériel ne prend beaucoup de planification qui est difficile à prédire.

    Bien qu'il n'est pas pratique je pense que les compilateurs doivent soutenir un pragma qui marque une fonction de mesure. Le compilateur peut alors inclure de haute précision non-intrusive points de mesure dans le prologue et l'épilogue d'une fonction et d'interdire toute inline de la fonction. En fonction de l'architecture, il peut choisir une haute précision de l'horloge pour mesurer le temps, de préférence avec le soutien de l'OS à seulement mesurer le temps de la processus actuel.

    selon cplusplus.com/reference/ctime/clock j'ai besoin de diviser clocks différence par CLOCKS_PER_SEC, droit? Mais votre point est, seulement avec 100000 ou plus d'itérations que je peux voir des résultats en quelques secondes?
    Mon point est que même si CLOCKS_PER_SEC est de 1000000, le clock fonction sera de retour multiples de 10000 sur mon système et je suppose que sur la plupart des systèmes Linux. Donc, pour obtenir une mesure raisonnable, vous devez exécuter l'application pour au moins quelques dixièmes de secondes. Mais vraiment mon point est qu'il est très difficile de faire ce genre de micro-mesures sur le code, parce que le compilateur est pas au courant de ce que vous voulez mesurer et pouvez planifier vos points de mesure de manière inattendue.
    J'ai ajouté un peu plus de l'élaboration de micro-mesures.

    OriginalL'auteur Bryan Olivier