Temps d'exécution du programme C

J'ai un programme C qui vise à être exécuté en parallèle sur plusieurs processeurs. Je dois pouvoir enregistrer le temps d'exécution (qui peut aller de 1 seconde à plusieurs minutes). J'ai cherché des réponses, mais elles semblent toutes suggérer d'utiliser la clock()fonction, ce qui implique ensuite de calculer le nombre d'horloges prises par le programme divisé par la Clocks_per_secondvaleur.

Je ne sais pas comment la Clocks_per_secondvaleur est calculée?

En Java, je prends juste l'heure actuelle en millisecondes avant et après l'exécution.

Y a-t-il une chose similaire en C? J'ai jeté un coup d'œil, mais je n'arrive pas à trouver un moyen d'obtenir quelque chose de mieux qu'une deuxième résolution.

Je suis également conscient qu'un profileur serait une option, mais je cherche à implémenter un minuteur moi-même.

Merci

CLOCKS_PER_SECest une constante qui est déclarée en <time.h>. Pour obtenir le temps CPU utilisé par une tâche dans une application C, utilisez:

clock_t begin = clock();

/* here, do your time-consuming job */

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Notez que cela renvoie l'heure comme un type à virgule flottante. Cela peut être plus précis qu'une seconde (par exemple, vous mesurez 4,52 secondes). La précision dépend de l'architecture; sur les systèmes modernes, vous obtenez facilement 10 ms ou moins, mais sur les machines Windows plus anciennes (de l'ère Win98), elle était plus proche de 60 ms.

clock()est la norme C; ça marche "partout". Il existe des fonctions spécifiques au système, telles quegetrusage() sur les systèmes de type Unix.

Java System.currentTimeMillis()ne mesure pas la même chose. Il s'agit d'une "horloge murale": elle peut vous aider à mesurer le temps nécessaire au programme pour s'exécuter, mais elle ne vous indique pas combien de temps CPU a été utilisé. Sur un système multitâche (c'est-à-dire tous), ceux-ci peuvent être très différents.

Si vous utilisez le shell Unix pour l'exécution, vous pouvez utiliser la commande time.

Faire

$ time ./a.out

en supposant a.out que l'exécutable vous donnera le temps nécessaire pour exécuter cette

En vanille nature C:

#include <time.h>
#include <stdio.h>

int main()
{
    clock_t tic = clock();

    my_expensive_function_which_can_spawn_threads();

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

Vous voulez fonctionnellement cela:

#include <sys/time.h>

struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* stuff to do! */
gettimeofday(&tv2, NULL);

printf ("Total time = %f seconds\n",
         (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
         (double) (tv2.tv_sec - tv1.tv_sec));

Notez que cela mesure en microsecondes, pas seulement en quelques secondes.

La plupart des programmes simples ont un temps de calcul en millisecondes. Donc, je suppose que vous trouverez cela utile.

#include <time.h>
#include <stdio.h>

int main(){
    clock_t start = clock();
    // Execuatable code
    clock_t stop = clock();
    double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC;
    printf("Time elapsed in ms: %f", elapsed);
}

Si vous souhaitez calculer le temps d'exécution de l'ensemble du programme et que vous êtes sur un système Unix, exécutez votre programme en utilisant la commande time comme celle-citime ./a.out

Beaucoup de réponses ont été suggérées clock(), puis CLOCKS_PER_SECde time.h. C'est probablement une mauvaise idée, car voici ce que /bits/time.hdit mon dossier:

/* ISO/IEC 9899:1990 7.12.1: <time.h>
The macro `CLOCKS_PER_SEC' is the number per second of the value
returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#  define CLOCKS_PER_SEC  1000000l

#  if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system.  */
#   include <bits/types.h>
extern long int __sysconf (int);
#   define CLK_TCK ((__clock_t) __sysconf (2))  /* 2 is _SC_CLK_TCK */
#  endif

Donc, CLOCKS_PER_SECpourrait être défini comme 1000000, selon les options que vous utilisez pour compiler, et cela ne semble donc pas être une bonne solution.

La réponse de Thomas Pornin sous forme de macros:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

Utilisez-le comme ceci:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

Production:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

Vous devez tenir compte du fait que mesurer le temps exécution d'un programme dépend beaucoup de la charge de la machine à ce moment précis.

Sachant que, la manière d'obtenir l'heure actuelle en C peut être réalisée de différentes manières, la plus simple est:

#include <time.h>

#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \
  ruse.ru_stime.tv_sec + 1e-6 * \
  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

int main(void) {
    time_t start, end;
    double first, second;

    // Save user and CPU start time
    time(&start);
    first = CPU_TIME;

    // Perform operations
    ...

    // Save end time
    time(&end);
    second = CPU_TIME;

    printf("cpu  : %.2f secs\n", second - first); 
    printf("user : %d secs\n", (int)(end - start));
}

J'espère que ça aide.

Cordialement!

(Toutes les réponses manquent ici, si votre administrateur système modifie l'heure système ou si votre fuseau horaire a des heures d'hiver et d'été différentes. Par conséquent ...)

Sur Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); Cela n'est pas affecté si l'administrateur système modifie l'heure, ou si vous vivez dans un pays avec une heure d'hiver différente de l'heure d'été, etc.

#include <stdio.h>
#include <time.h>

#include <unistd.h> /* for sleep() */

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    sleep(1);      // waste some time

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf ("Total time = %f seconds\n",
            (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
            (end.tv_sec  - begin.tv_sec));

}

man clock_gettime États:

CLOCK_MONOTONIC
              Clock  that  cannot  be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

ANSI C spécifie uniquement les secondes fonctions temporelles de précision. Cependant, si vous exécutez dans un environnement POSIX, vous pouvez utiliser gettimeofday () qui fournit une résolution en microsecondes du temps écoulé depuis l'époque UNIX.

En guise de remarque, je ne recommanderais pas d'utiliser clock () car il est mal implémenté sur de nombreux systèmes (sinon tous?) Et n'est pas précis, outre le fait qu'il se réfère uniquement au temps que votre programme a passé sur le CPU et pas la durée de vie totale du programme, ce qui, selon votre question, est ce que je suppose que vous aimeriez mesurer.

Toutes les solutions ne fonctionnent pas dans mon système.

Je peux utiliser

#include <time.h>

double difftime(time_t time1, time_t time0);

    #include<time.h>
    #include<stdio.h>
    int main(){
clock_t begin=clock();

    int i;
for(i=0;i<100000;i++){
printf("%d",i);

}
clock_t end=clock();
printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC);
}

Ce programme fonctionnera comme un charme.

J'ai trouvé que l'horloge habituelle (), tout le monde le recommande ici, pour une raison quelconque, s'écarte énormément d'une exécution à l'autre, même pour du code statique sans aucun effet secondaire, comme dessiner à l'écran ou lire des fichiers. Cela pourrait être dû au fait que le processeur change les modes de consommation d'énergie, que le système d'exploitation donne différentes priorités, etc.

Ainsi, le seul moyen d'obtenir de manière fiable le même résultat à chaque fois avec clock () est d'exécuter le code mesuré en boucle plusieurs fois (pendant plusieurs minutes), en prenant des précautions pour empêcher le compilateur de l'optimiser: les compilateurs modernes peuvent précalculer le code sans effets secondaires en cours d'exécution dans une boucle, et déplacez-le hors de la boucle., comme c'est-à-dire en utilisant une entrée aléatoire pour chaque itération.

Une fois que suffisamment d'échantillons ont été collectés dans un tableau, on trie ce tableau et prend l'élément central, appelé médiane. La médiane est meilleure que la moyenne, car elle élimine les écarts extrêmes, comme par exemple l'antivirus occupant tout le processeur ou le système d'exploitation faisant une mise à jour.

Voici un utilitaire simple pour mesurer les performances d'exécution du code C / C ++, en faisant la moyenne des valeurs proches de la médiane: https://github.com/saniv/gauge

Je suis moi-même toujours à la recherche d'un moyen plus robuste et plus rapide de mesurer le code. On pourrait probablement essayer d'exécuter le code dans des conditions contrôlées sur du métal nu sans aucun système d'exploitation, mais cela donnera un résultat irréaliste, car en réalité, le système d'exploitation s'implique.

x86 a ces compteurs de performances matérielles, qui incluent le nombre réel d'instructions exécutées, mais ils sont difficiles à accéder sans l'aide du système d'exploitation, difficiles à interpréter et ont leurs propres problèmes ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Ils pourraient tout de même être utiles pour enquêter sur la nature du col de la bouteille (accès aux données ou calculs réels sur ces données).

Certains pourraient trouver un autre type d'entrée utile: on m'a donné cette méthode de mesure du temps dans le cadre d'un cours universitaire sur la programmation GPGPU avec NVidia CUDA ( description du cours ). Il combine des méthodes vues dans des articles précédents, et je le poste simplement parce que les exigences lui donnent de la crédibilité:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

Je suppose que vous pourriez multiplier par exemple 1.0 / 1000.0pour obtenir l'unité de mesure qui convient à vos besoins.

Comparaison du temps d'exécution du tri à bulles et du tri par sélection J'ai un programme qui compare le temps d'exécution du tri à bulles et du tri par sélection. Pour connaître l'heure d'exécution d'un bloc de code, calculer l'heure avant et après le bloc en

 clock_t start=clock();
 …
 clock_t end=clock();
 CLOCKS_PER_SEC is constant in time.h library

Exemple de code:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
   int a[10000],i,j,min,temp;
   for(i=0;i<10000;i++)
   {
      a[i]=rand()%10000;
   }
   //The bubble Sort
   clock_t start,end;
   start=clock();
   for(i=0;i<10000;i++)
   {
     for(j=i+1;j<10000;j++)
     {
       if(a[i]>a[j])
       {
         int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
       }
     }
   }
   end=clock();
   double extime=(double) (end-start)/CLOCKS_PER_SEC;
   printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime);

   for(i=0;i<10000;i++)
   {
     a[i]=rand()%10000;
   }
   clock_t start1,end1;
   start1=clock();
   // The Selection Sort
   for(i=0;i<10000;i++)
   {
     min=i;
     for(j=i+1;j<10000;j++)
     {
       if(a[min]>a[j])
       {
         min=j;
       }
     }
     temp=a[min];
     a[min]=a[i];
     a[i]=temp;
   }
   end1=clock();
   double extime1=(double) (end1-start1)/CLOCKS_PER_SEC;
   printf("\n");
   printf("\tExecution time for the selection sort is %f seconds\n\n", extime1);
   if(extime1<extime)
     printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1);
   else if(extime1>extime)
     printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime);
   else
     printf("\tBoth algorithms have the same execution time\n\n");
}