Comment puis-je trouver le temps d'exécution d'une partie de mon programme en C?

J'essaie de trouver un moyen d'obtenir le temps d'exécution d'une section de code en C. j'ai déjà essayé deux fois() et de l'horloge() de temps.h, mais il semble que le temps() renvoie des secondes et de l'horloge() semble me donner millisecondes (ou centièmes de seconde?) Je voudrais quelque chose de plus précis. Est-il possible que je peux attraper le temps avec au moins microseconde de précision?

Ce ne doit être en mesure de compiler sur Linux.

OriginalL'auteur Stephen Booher | 2008-10-06

  1. 15

    Vous visées à clock() et time() - avez-vous été à la recherche pour gettimeofday()?
    Qui va remplir un struct timeval, qui contient secondes et microsecondes.

    Bien sûr, la résolution réelle est en place pour le matériel.

    OriginalL'auteur

  2. 12

    Pour ce que ça vaut, en voici une qui est juste un peu de 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);

    Puis il suffit de l'utiliser avec:

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

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

    OriginalL'auteur

  3. 11

    Vous voulez un profiler application.

    De recherche de mots-clés et DONC les moteurs de recherche: linux profilage

    Un Profileur donne des informations statistiques, ce qui n'est pas le même comme une mesure réelle.

    OriginalL'auteur

  4. 3

    Ont un coup d'oeil à gettimeofday,
    clock_*, ou get/setitimer.

    OriginalL'auteur

  5. 2

    Essayer "le banc.h"; il vous permet de mettre un START_TIMER; et STOP_TIMER("nom"); dans votre code, vous permettant de référence arbitrairement une section de code (note: recommandé uniquement pour de courtes sections, et non pas les choses en prenant des dizaines de millisecondes ou plus). Sa précision de l'horloge du cycle, bien que dans certains cas rares, il peut changer la façon dont le code est compilé, dans ce cas, vous êtes mieux avec un profiler (même si ceux-ci sont généralement plus d'efforts pour les utiliser pour des articles de code).

    Il ne fonctionne que sur x86.

    Nice one, nous avons un similaire, avec complément utile, PERF_MARK. Cela permettra à la marque de se multiplier point stockées dans le tableau statique. Nous avons une version qui peut enregistrer une chaîne de caractères pour faciliter la lecture des résultats, le tableau contient 100 entrées par défaut, mais peut être changé. PERF_STOP dump les résultats.
    Pour quiconque a ajouté la remarque à propos de ce défaut sur les systèmes multi-core: je l'ai supprimé, car il est tout simplement incorrecte. La macro gère automatiquement les changements de contexte et d'autres changements brusques de RDTSC valeurs, donc pas de probleme de ce genre existe. Je l'utilise exclusivement le multi-core machines et il fonctionne très bien.
    Sombre Shikari: Cela ne peut être correcte, Cette macro ne peut pas gérer les choses comme préférentiel de souscription des changements de contexte. Il tout simplement pas. Il va produire des résultats, mais ils ne seront pas précises. Aussi le temps qu'elle renvoie est calibré pour un processeur Core2 (en raison de #define NOP_CYCLES) & aurait besoin d'être modifié pour répondre aux besoins.

    OriginalL'auteur

  6. 1

    Vous pourriez vouloir à google pour un instrumentation outil.

    OriginalL'auteur

  7. 1

    Vous ne trouverez pas un appel de la bibliothèque qui vous permet d'obtenir le passé de l'horloge de la résolution de votre plate-forme. Soit utiliser un profiler (homme gprof) comme une autre affiche a été suggéré, ou - rapide & sale - mettre une boucle autour de la délinquance de la section de code à exécuter de nombreuses fois, et l'utilisation de l'horloge().

    OriginalL'auteur

  8. 1

    gettimeofday() vous offre une résolution de quelques microsecondes, alors que clock_gettime() vous offre une résolution de nanosecondes. 

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

    La clk_id identifie l'horloge à être utilisé. Utilisation CLOCK_REALTIME si vous voulez un système à l'échelle de l'horloge visible à tous les processus. Utilisation CLOCK_PROCESS_CPUTIME_ID pour chaque processus de la minuterie et CLOCK_THREAD_CPUTIME_ID pour un thread spécifique de la minuterie.

    OriginalL'auteur

  9. 0

    Il dépend des conditions.. Profileurs sont agréables pour l'ensemble des vues toutefois, si vous avez vraiment besoin d'une vision précise et ma recommandation est de BAISER. Il suffit d'exécuter le code dans une boucle, tel que cela prend une minute pour terminer. Ensuite, on calcule une moyenne simple basé sur le temps d'exécution et les itérations exécutées.

    Cette approche permet de:

    1. Obtenir des résultats précis avec une faible résolution des chronomètres.

    2. Courez pas dans les problèmes où l'instrumentation interfère avec la haute la vitesse de la mémoire cache (l2,l1,direction etc..) à proximité du processeur. Cependant exécutant le même code dans une boucle serrée, peut également fournir des résultats optimistes qui peuvent ne pas refléter les conditions du monde réel.

    OriginalL'auteur

  10. 0

    Ne sais pas qui de l'environnement/système d'exploitation que vous travaillez, mais votre temps peut être inexacte si un autre thread, une tâche ou un processus, anticipe sur votre chronométré code dans le milieu. Je suggère d'explorer des mécanismes tels que les mutex ou les sémaphores pour empêcher les autres threads preemting votre processus.

    OriginalL'auteur

  11. 0

    Si vous développez sur x86 ou x64, pourquoi ne pas utiliser le Time Stamp Counter: RDTSC.

    Il sera plus fiable, Ansi C, comme les fonctions time() ou une horloge() RDTSC est atomique fonction. À l'aide de fonctions C pour cela peut introduire des problèmes que vous avez aucune garantie que le fil qu'ils sont en cours d'exécution ne sera pas mis à l'écart et en conséquence, la valeur de leur retour ne sera pas une description exacte de l'exécution réelle du temps que vous essayez de mesurer.

    Avec RDTSC vous pouvez mieux mesurer ce. Vous aurez besoin de convertir le nombre de graduation de retour dans une lisible par l'homme heure H:M:S format qui dépendra de la fréquence d'horloge des processeurs, mais autour de google et je suis sûr que vous trouverez des exemples.

    Cependant, même avec RDTSC vous serez en incluant le temps de votre code a été mis hors d'exécution, tandis qu'une meilleure solution que d'utiliser time()/clock() si vous avez besoin d'une mesure exacte, vous aurez à se tourner vers un profiler qui sera l'instrument de votre code et de prendre en compte lors de votre code n'est pas réellement de l'exécution en raison de changements de contexte ou de quoi que ce soit.

    OriginalL'auteur