Comment trouver le temps d'exécution d'une section de mon programme en C?

StackOverflow https://stackoverflow.com/questions/173409

  •  05-07-2019
  •  | 
  •  

Question

J'essaie de trouver un moyen d'obtenir l'heure d'exécution d'une section de code en C. J'ai déjà essayé time () et clock () de time.h, mais il semble que time () renvoie secondes et clock () semble me donner des millisecondes (ou des centisecondes?) Je voudrais quelque chose de plus précis. Est-il possible de saisir l'heure avec une précision d'au moins une microseconde?

Ceci ne doit être compilé que sous Linux.

Était-ce utile?

La solution

Vous avez parlé de clock () et de time () - recherchiez-vous gettimeofday () ? Cela remplira un struct timeval , qui contient les secondes et les microsecondes.

Bien entendu, la résolution réelle dépend du matériel.

Autres conseils

Pour ce que ça vaut, en voici une qui ne contient que quelques macros: 

#include <time.h>
clock_t startm, stopm;
#define START if ( (startm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define STOP if ( (stopm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define PRINTTIME printf( "%6.3f seconds used by the processor.", ((double)stopm-startm)/CLOCKS_PER_SEC);

Ensuite, utilisez-le simplement avec: 

main() {
  START;
  // Do stuff you want to time
  STOP;
  PRINTTIME;
}

De http://ctips.pbwiki.com/Timer

Vous souhaitez une application profiler .

Recherche de mots clés dans les moteurs de recherche et les moteurs de recherche: profilage linux

Essayez " bench.h " ; il vous permet de mettre un START_TIMER; et STOP_TIMER ("nom"); dans votre code, ce qui vous permet d'analyser arbitrairement toute section de code (remarque: recommandé uniquement pour les sections courtes, et non pour les éléments prenant des dizaines de millisecondes ou plus). Sa précision par rapport au cycle d'horloge, bien que dans de rares cas, elle puisse modifier la manière dont le code est compilé, auquel cas il vaut mieux utiliser un profileur (bien que les profileurs déploient généralement plus d'efforts pour certaines sections de code).

Cela ne fonctionne que sur x86.

Vous pouvez vouloir rechercher un outil d'instrumentation .

Vous ne trouverez pas d'appel de bibliothèque vous permettant de dépasser la résolution d'horloge de votre plate-forme. Soit utilisez un profileur (man gprof) comme une autre affiche suggérée, soit - quick & amp; dirty - faites une boucle autour de la section de code incriminée pour l'exécuter plusieurs fois, et utilisez clock ().

gettimeofday () vous fournit une résolution de microsecondes, alors que < code> clock_gettime () vous fournit une résolution en nanosecondes. 

int clock_gettime(clockid_t clk_id, struct timespec *tp);

Le clk_id identifie l'horloge à utiliser. Utilisez CLOCK_REALTIME si vous souhaitez une horloge système visible par tous les processus. Utilisez CLOCK_PROCESS_CPUTIME_ID pour le temporisateur par processus et CLOCK_THREAD_CPUTIMEID pour un minuteur spécifique à un thread.

Cela dépend des conditions. Les profileurs sont bien pour les vues globales générales, cependant si vous avez vraiment besoin d’une vue précise, ma recommandation est KISS. Exécutez simplement le code dans une boucle telle qu'il faut environ une minute à la fin. Ensuite, calculez une moyenne simple basée sur le temps d’exécution total et les itérations exécutées.

Cette approche vous permet de:

  1. Obtenez des résultats précis avec des minuteries à faible résolution.

  2. Ne rencontrez pas de problèmes d'ingérence de l'instrumentation dans les caches à grande vitesse (l2, l1, branch..etc) proches du processeur. Cependant, l’exécution du même code dans une boucle étroite peut également fournir des résultats optimistes qui peuvent ne pas refléter les conditions réelles.

Vous ne savez pas sur quel environnement / système d'exploitation vous travaillez, mais votre minutage risque d'être imprécis si un autre thread, une autre tâche ou un autre processus préempte votre code temporisé au milieu. Je suggère d'explorer des mécanismes tels que les mutex ou les sémaphores afin d'empêcher d'autres threads de pré-intégrer votre processus.

Si vous développez sous x86 ou x64, pourquoi ne pas utiliser le compteur d'horodatage: RDTSC .

Il sera plus fiable que Ansi C comme time () ou clock (), puisque RDTSC est une fonction atomique. L'utilisation de fonctions C à cette fin peut poser des problèmes, car vous n'avez aucune garantie que le thread dans lequel elles s'exécutent ne sera pas déconnecté et, par conséquent, la valeur qu'elles renverront ne sera pas une description précise du temps d'exécution réel que vous essayez de mesurer. .

Avec RDTSC, vous pouvez mieux mesurer cela. Vous devrez reconvertir le nombre de ticks en une heure lisible par l’homme au format H: M: S, qui dépendra de la fréquence d’horloge des processeurs, mais google et je suis sûr que vous trouverez des exemples.

Cependant, même avec RDTSC, vous incluez l'heure à laquelle votre code a été mis hors exécution, mais une meilleure solution que d'utiliser time () / clock () si vous avez besoin d'une mesure exacte, vous devrez vous adresser à un profileur instrumentez votre code et prenez en compte le moment où votre code ne s'exécute pas en raison de changements de contexte ou autre.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top