Meilleure méthode de chronométrage en C?
Quel est le meilleur moyen de chronométrer une section de code avec une résolution et une portabilité élevées?
/* Time from here */
ProcessIntenseFunction();
/* to here. */
printf("Time taken %d seconds %d milliseconds", sec, msec);
Existe-t-il une bibliothèque standard offrant une solution multiplate-forme?
Je pense que cela devrait fonctionner:
#include <time.h>
clock_t start = clock(), diff;
ProcessIntenseFunction();
diff = clock() - start;
int msec = diff * 1000 / CLOCKS_PER_SEC;
printf("Time taken %d seconds %d milliseconds", msec/1000, msec%1000);
gettimeofday () fera probablement ce que vous voulez.
Si vous utilisez du matériel Intel, voici comment lire le compteur d’instructions en temps réel de la CPU. Il vous indiquera le nombre de cycles de la CPU exécutés depuis le démarrage du processeur. C'est probablement le compteur de frais généraux le plus fin et le plus fin que vous pouvez obtenir pour mesurer les performances.
Notez qu'il s'agit du nombre de cycles de la CPU. Sous Linux, vous pouvez obtenir la vitesse du processeur à partir de/proc/cpuinfo et diviser pour obtenir le nombre de secondes. La convertir en un double est très pratique.
Lorsque je lance ceci sur ma boîte, je reçois
11867927879484732 11867927879692217 Il a fallu longtemps pour appeler printf: 207485
Voici le Guide du développeur Intel qui donne une tonne de détails.
#include <stdio.h>
#include <stdint.h>
inline uint64_t rdtsc() {
uint32_t lo, hi;
__asm__ __volatile__ (
"xorl %%eax, %%eax\n"
"cpuid\n"
"rdtsc\n"
: "=a" (lo), "=d" (hi)
:
: "%ebx", "%ecx");
return (uint64_t)hi << 32 | lo;
}
main()
{
unsigned long long x;
unsigned long long y;
x = rdtsc();
printf("%lld\n",x);
y = rdtsc();
printf("%lld\n",y);
printf("it took this long to call printf: %lld\n",y-x);
}
gettimeofday rendra l'heure exacte en microsecondes dans la résolution de l'horloge système. Vous pouvez également consulter le projet High Res Timers sur SourceForge.
J'utilise SDL_GetTicks à partir de la bibliothèque SDL .
Si vous ne voulez pas de temps CPU, je pense que vous cherchez la structure timeval.
J'utilise ce qui suit pour calculer le temps d'exécution:
int timeval_subtract(struct timeval *result,
struct timeval end,
struct timeval start)
{
if (start.tv_usec < end.tv_usec) {
int nsec = (end.tv_usec - start.tv_usec) / 1000000 + 1;
end.tv_usec -= 1000000 * nsec;
end.tv_sec += nsec;
}
if (start.tv_usec - end.tv_usec > 1000000) {
int nsec = (end.tv_usec - start.tv_usec) / 1000000;
end.tv_usec += 1000000 * nsec;
end.tv_sec -= nsec;
}
result->tv_sec = end.tv_sec - start.tv_sec;
result->tv_usec = end.tv_usec - start.tv_usec;
return end.tv_sec < start.tv_sec;
}
void set_exec_time(int end)
{
static struct timeval time_start;
struct timeval time_end;
struct timeval time_diff;
if (end) {
gettimeofday(&time_end, NULL);
if (timeval_subtract(&time_diff, time_end, time_start) == 0) {
if (end == 1)
printf("\nexec time: %1.2fs\n",
time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f));
else if (end == 2)
printf("%1.2fs",
time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f));
}
return;
}
gettimeofday(&time_start, NULL);
}
void start_exec_timer()
{
set_exec_time(0);
}
void print_exec_timer()
{
set_exec_time(1);
}
La haute résolution est relative ... Je regardais les exemples et ils s’occupent principalement de millisecondes. Cependant, pour moi, il est important de mesurer des microsecondes. Je n'ai pas vu de solution indépendante de la plateforme pour les microsecondes et je pensais que quelque chose comme le code ci-dessous serait utile. Je ne surveillais que pour l'instant les fenêtres et j'ajouterai très probablement une implémentation de gettimeofday () lors de la même procédure sous AIX/Linux.
#ifdef WIN32
#ifndef PERFTIME
#include <windows.h>
#include <winbase.h>
#define PERFTIME_INIT unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; unsigned __int64 endTime; double timeDifferenceInMilliseconds;
#define PERFTIME_START QueryPerformanceCounter((LARGE_INTEGER *)&startTime);
#define PERFTIME_END QueryPerformanceCounter((LARGE_INTEGER *)&endTime); timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds);
#define PERFTIME(funct) {unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; QueryPerformanceCounter((LARGE_INTEGER *)&startTime); unsigned __int64 endTime; funct; QueryPerformanceCounter((LARGE_INTEGER *)&endTime); double timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds);}
#endif
#else
//AIX/Linux gettimeofday() implementation here
#endif
Usage:
PERFTIME(ProcessIntenseFunction());
or
PERFTIME_INIT
PERFTIME_START
ProcessIntenseFunction()
PERFTIME_END