clock() de la précision dans le temps.h

Je suis en train de calculer le nombre de tiques une fonction utilise pour exécuter et à faire une utilisation de la clock() fonction de la façon:

unsigned long time = clock();
myfunction();
unsigned long time2 = clock() - time;
printf("time elapsed : %lu",time2);

Mais le problème est que la valeur qu'elle renvoie est un multiple de 10000, ce qui je pense est le CLOCK_PER_SECOND. Est-il un moyen ou une fonction équivalente de la valeur qui est la plus précise?

J'utilise Ubuntu 64 bits, mais préférez si la solution peut fonctionner sur d'autres systèmes comme Windows & Mac OS.

voir stackoverflow.com/questions/538609/...
Ce n'est pas une bonne idée de nommer une variable time, surtout si vous utilisez <time.h>, puisqu'il y a une fonction standard de ce nom.
j'ai utilisé le temps comme nom de variable dans le seul but de la question.

OriginalL'auteur mteffaha | 2011-12-21

  1. 8

    Il y a un certain nombre de plus précis de minuteurs dans POSIX.

    • gettimeofday() - officiellement obsolète, mais très largement disponibles; microseconde résolution.
    • clock_gettime() - le remplacement de gettimeofday() (mais pas forcément disponibles partout; sur une ancienne version de Solaris, nécessite -lposix4 lien), avec une résolution d'une.

    Il y a d'autres sous-deuxième temps de plus ou moins de l'antiquité, la portabilité, et la résolution, y compris:

    • ftime() - milliseconde (marqué d '"héritage" dans POSIX 2004; pas dans POSIX 2008).
    • horloge() - ce qui vous connaissent déjà. Noter que les mesures de temps de CPU, pas écoulée (horloge murale).
    • fois() - CLK_TCK ou HZ. Notez que cette mesures de temps PROCESSEUR pour les processus parents et enfants.

    Ne pas utiliser ftime() ou times() à moins qu'il n'y a rien de mieux. Le recours ultime, mais ne répondant pas à vos besoins immédiats, est

    • time() - une résolution d'une seconde.

    La clock() fonction des rapports dans les unités de CLOCKS_PER_SEC, qui est nécessaire pour être 1 000 000 de par POSIX, mais l'incrément peut se produire moins fréquemment (100 fois par seconde a été l'une fréquence commune). La valeur de retour doit être défini par CLOCKS_PER_SEC obtenir le temps en secondes.

    Eh bien le fait qu'il est disponible sur Solaris est une bonne chose. Encore une OS en s'efforçant de POSIX conformité. Cela dit cependant, n'est pas POSIX mandat que le symbole, être disponible au moins -lrt?
    J'ai écrit ces notes il y a longtemps - peut-être Solaris 2.6 ère (hmmm...1998...oui, tout à fait un, tout à l'heure!). Si la bibliothèque requise peut avoir changé.
    Le lien est à POSIX 2008 et il est toujours répertorié comme une partie de la norme POSIX, quoique marquée obsolète depuis le Numéro 7 (qui est la POSIX 2008 standard; voir la rubrique des pages liées). Donc, je crois que vous êtes prématurée lors de la déclaration de gettimeofday() obsolète; il est juste de caducité de toujours.
    clock() sur Linux sur plate-forme x86 AUSSI a 1 seconde résolution. Il est incrémentée de 10 000 fois par seconde.
    Je pense que clock() sur Linux a probablement 1/100 de seconde résolution. CLOCKS_PER_SEC est nécessaire à 1 000 000 (et est donc définie sur RedHat 5.3 dans /usr/include/time.h). Vous mentionnez incrémentée de 10 000 habitants, qui devra être faite 100 fois par seconde pour atteindre le taux de l'augmentation de 1 000 000 par seconde. Il est à noter que clock() mesures de temps de CPU, pas de temps écoulé. (Voir Tri des 2 tableaux à l'aide de 2 fils prend plus de temps que le tri des 2 tables une à la fois pour plus d'information.)

    OriginalL'auteur Jonathan Leffler

  2. 1

    Par l'horloge (en) page de manuel, sur les plate-formes POSIX la valeur de la CLOCKS_PER_SEC macro doit être 1000000. Autant vous dire que la valeur de retour vous obtenez à partir de l'horloge() est un multiple de 10000, ce qui impliquerait que la résolution est de 10 ms.

    Notez aussi que l'horloge() sur Linux renvoie une approximation du temps processeur utilisé par le programme. Sur Linux, encore une fois, le planificateur de statistiques sont mises à jour lorsque l'ordonnanceur fonctionne, à CONFIG_HZ fréquence. Donc, si le minuteur périodique tique est de 100 Hz, vous obtenez processus de temps CPU statistiques sur la consommation par pas de 10 ms.

    Walltime mesures ne sont pas liés par le présent, et peut être beaucoup plus précis. clock_gettime(CLOCK_MONOTONIC, ...) sur un système Linux offre une résolution d'une.

    merci tous les corps pour vos réponses , j'ai pu faire avec clock_gettime .

    OriginalL'auteur janneb

  3. 1

    Le plus précis (mais très pas portable) pour mesurer le temps, il suffit de compter les cycles de l'UC.

    Par exemple sur x86

     unsigned long long int asmx86Time ()
 {
   unsigned long long int realTimeClock = 0;
   asm volatile ( "rdtsc\n\t"         
                  "salq $32, %%rdx\n\t"    
                  "orq %%rdx, %%rax\n\t"   
                  "movq %%rax, %0"         
                  : "=r" ( realTimeClock ) 
                  : /* no inputs */
                  : "%rax", "%rdx" );
   return realTimeClock;
 }

 double cpuFreq ()
 {
   ifstream file ( "/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq" );
   string sFreq; if ( file ) file >> sFreq;
   stringstream ssFreq ( sFreq ); double freq = 0.;
   if ( ssFreq ) { ssFreq >> freq; freq *= 1000; } //kHz to Hz
   return freq;
 }

 //Timing

 unsigned long long int asmStart = asmx86Time ();
 doStuff ();
 unsigned long long int asmStop  = asmx86Time ();
 float asmDuration = ( asmStop - asmStart ) / cpuFreq ();

    Si vous ne disposez pas d'un système x86, vous aurez à ré-écrire le code assembleur en conséquence de votre CPU. Si vous besoin un maximum de précision, c'est malheureusement la seule façon d'aller... sinon utiliser clock_gettime().

    OriginalL'auteur FGH

  4. -1

    Je suis d'accord avec la solution de Jonathan. Ici est la mise en œuvre de clock_gettime() avec nanosecondes de précision. 

    //Import 
 #define _XOPEN_SOURCE 500
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <time.h>
 #include <sys/time.h>


 int main(int argc, char *argv[])
 {   
     struct timespec ts;
     int ret;
     while(1)
     {
         ret = clock_gettime (CLOCK_MONOTONIC, &ts);
         if (ret) 
         {
             perror ("clock_gettime");
             return;
         }
         ts.tv_nsec += 20000; //goto sleep for 20000 n
         printf("Print before sleep tid%ld %ld\n",ts.tv_sec,ts.tv_nsec );
        //printf("going to sleep tid%d\n",turn );
         ret = clock_nanosleep (CLOCK_MONOTONIC, TIMER_ABSTIME,&ts, NULL);

     }
 }

    Bien qu'Il est difficile de réaliser des ns de précision, mais cela peut être utilisé pour obtenir une précision de moins d'une microseconde (700-900 ns). printf ci-dessus est utilisé pour imprimer le thread # (il va certainement prendre 2-3 micro secondes pour imprimer une déclaration).

    OriginalL'auteur Scissor