web-dev-qa-db-fra.com

Comment mesurer le temps d'exécution réel d'un programme C sous Linux?

Je sais que cette question a peut-être été fréquemment posée auparavant, mais il semble que la plupart de ces questions concernent le temps {elapsed (d’un horloge murale) d’un morceau de code. Le temps elapsed d'un morceau de code est peu probable égal au temps d'exécution real, d'autres processus pouvant s'exécuter pendant le écoulé heure du code d’intérêt.

J'ai utilisé getrusage () pour obtenir l'heure utilisateur et l'heure système d'un processus, puis calculer le temps d'exécution réel par (heure utilisateur + heure système). Je lance mon programme sur Ubuntu. Voici mes questions:

  1. Comment connaître la précision de getrusage ()?
  2. Existe-t-il d'autres approches pouvant fournir une précision supérieure à celle de getrusage ()?
clinuxtime
22
Dillon Geo

Vous pouvez vérifier le temps CPU réel d'un processus sous Linux en utilisant la fonctionnalité CPU Time du noyau:

 #include <time.h>

 clock_t start, end;
 double cpu_time_used;

 start = clock();
 ... /* Do the work. */
 end = clock();
 cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;

Source: http://www.gnu.org/s/hello/manual/libc/CPU-Time.html#CPU-Time

De cette façon, vous comptez les ticks du processeur ou la quantité réelle d'instructions exécutées par le processeur sur le processus, obtenant ainsi la quantité réelle de temps de travail.

18
Lars

La fonction getrusage () est la seule méthode standard/portable que je connaisse pour obtenir le "temps CPU consommé".

Il n'existe pas de moyen simple de déterminer la précision des valeurs renvoyées. Je serais tenté d'appeler getrusage () une fois pour obtenir une valeur initiale, et l'appelez-le plusieurs fois jusqu'à ce que la/les valeur (s) renvoyée (s) soit différent (s) de la valeur initiale, puis supposez que la précision effective est la différence entre les valeurs initiale et finale. valeurs. C'est un hack (il serait possible que la précision soit supérieure à ce que cette méthode détermine, et le résultat devrait probablement être considéré comme la pire estimation possible), mais c'est mieux que rien.

Je serais également préoccupé par l'exactitude des valeurs renvoyées. Dans certains noyaux, je suppose qu'un compteur est incrémenté pour le code en cours d'exécution lorsqu'une temporisation IRQ se produit. et par conséquent, il est possible qu'un processus soit très chanceux (et bloque en permanence juste avant la temporisation de l'IRQ) ou très malchanceux (et débloque juste avant que la temporisation de l'IRQ ne se produise). Dans ce cas, "chanceux" peut signifier qu'un cochon de processeur ne consomme pas de temps de calcul, et "malchanceux", un processus qui utilise très peu de temps de calcul ressemble à un cochon de calcul.

Pour des versions spécifiques de noyaux spécifiques sur une architecture/s spécifique (potentiellement si/lorsque le noyau est compilé avec des options de configuration spécifiques dans certains cas), il peut exister des alternatives de précision plus élevée qui ne sont pas portables et ne sont pas standard ...

4
Brendan

Vous pouvez utiliser ce morceau de code:

#include <sys/time.h>
struct timeval start, end;
gettimeofday(&start, NULL);
.
.
.
gettimeofday(&end, NULL);
delta = ((end.tv_sec  - start.tv_sec) * 1000000u +
         end.tv_usec - start.tv_usec) / 1.e6;
printf("Time is : %f\n",delta);

Il vous montrera le temps d'exécution pour une partie de votre code

1
pooria