Timer precis pour mesurer le temps d'execution d'une boucle - Page 1

Bonjour,

J'aurais besoin dans mon programme de savoir combien de temps s'est écoulé depuis le début de ma boucle principale. Cette boucle est rapide (elle se répète plusieurs fois par secondes), donc je ne peux pas utiliser des fonctions comme clock() ou time(), dont la précision est la seconde.
Je cherche donc un timer assez précis pour connaître combien de temps s'est exécuté entre le début de ma boucle et un autre endroit de cette boucle. J'aimerais obtenir ce temps en secondes (quelque chose comme 0.001 s).
J'ai entendu parler de GetTickCount(), mais je ne sais pas comment l'utiliser, et gprof n'a pas l'air adapté non plus (si j'ai bien compris le résultat est interprété après la fermeture du programme?).
Voilà, donc je cherche une autre manière de mesurer un temps très bref.

Merci d'avance pour votre aide!

GetTickCount ne fera pas ce que tu veux. Sa résolution est trop mauvaise (1 ms au mieux, et en fait 10 ms sur les systèmes NT).

Tu doit pouvoir arriver à un meilleur résultat avec QueryPerformanceCounter, qui fonctionne sur le même principe, mais avec une meilleure résolution (QueryPerformanceFrequency permet de trouver la résolution).

Note que avec ça tu mesures le temps écoulé depuis le début de la boucle principale. Ce n'est pas la même chose que le temps utilisé par ton programme depuis le début de la boucle principale.

En Assembleur, je te conseillerais l'utilisation de la paire d'instructions cpuid/rdtsc, mais je n'y connais rien en asm inline (à vrai dire, en C/C++ non plus ...).
Mais s'il existe une implémentation C/C++ de ces instructions, tu as tout ce qu'il te faut , tu te débrouilleras bien mieux que moi pour les utiliser !

D'ailleurs, je suis en train de faire en Asm un programme de test de vitesse de bouts de code, donc si tu peux obtenir le listing Asm de ta boucle (en syntaxe NAsm STP, ou tout au moins Intel), je peux l'implémenter en dur dans mon source et t'envoyer le programme compilé.
Ou alors, tu attends quelques jours que je finalise mon programme ...

@++

gprof n'a pas l'air adapté non plus (si j'ai bien compris le résultat est interprété après la fermeture du programme?).

gprof? je suppose que t'es sous un unix?
QueryPerformanceCounter ne marche que sur des windows, ca n'existe pas sur les unix.
a la place utilise la fct gettimeofday (man gettimeofday )

sinon a la limite ce qu'a dit ethaniel, mais je doute que t'aie besoin d'utiliser le rdtsc

Non je suis sous Windows, et j'utilise Dev-c++. QueryPerformanceCounter fonctionne aussi sous Dev-C++, ou seulement sous Visual Basic? Si oui, comment s'en sert-on?
Je débute encore en C, et je ne connais rien à l'asm. Pourriez-vous m'indiquer comment on se sert de cpuid/rdtsc?

Merci d'avance!

ah y a gprof sous windows aussi? chavais pas

oui, tu peux utiliser aussi QueryPerformanceCounter/Freq en C ou en C++
oublie le rdtsc, QueryPerformanceCounter est largement suffisant.
et "comment s'en sert-on?", tu vas sur google, et tu cherche "QueryPerformanceCounter"
ou sur msdn.microsoft.com

sBibi

p_y_a
?

Bon, finalement j'ai trouvé une solution convenable en utilisant clock(): toutes les secondes (temps minimum pour clock), je calcule combien de boucles ont été exécutées (une simple variable incrémentée à chaque fois), et j'en déduis le temps d'exécution d'une boucle. Cela me permet d'avoir un temps assez précis, sans que les données s'actualisent toutes les secondes.
Voici ma fonction:

float t; // Durée d'une boucle en s
clock_t t1; // Temps de référence pour mesurer la durée d'une boucle
double t2=1; // Temps permettant de mesurer la durée d'une boucle
int nb_boucles=100; // Nombre de boucles pour déterminer le temps par boucle

void temps_boucle() {

if (t2>=1) { // Toutes les secondes
t=t2/nb_boucles; // Ajuste le temps d'execution d'une boucle
t2=0;t1=clock();nb_boucles=0; // Réinitialise les variables
}
else {
t2=((double) clock()-t1)/CLOCKS_PER_SEC; // Calcule le temps écoulé depuis la dernière initialisation
nb_boucles++; // Augmente le nombre de boucles exécutées
}
}

Voilà, merci quand même pour votre aide.

lol...
c'est si dur que ca de lire la doc sur msdn ou de faire une recherche sur google?

clock c'est plus précis que toute les secondes: c'est au centieme de secondes pres. De plus, clock renvoie un double , donc tu peux virer le (double)

#ifndef __TIMMING__H__
#define __TIMMING__H__

#include <stdio.h>
#include <stdlib.h>

#ifndef __GNUC__
# error  CC != GCC 
#endif

/* High accuracy timing */
#if defined (__i386__) || defined(__amd64__)

#define read_rdtsc_before(time) \
        __asm__ __volatile__( \
                ".align 64\n\t" \
                "xor %%eax,%%eax\n\t" \
                "cpuid\n\t" \
                "rdtsc\n\t" \
                "mov %%eax,(%0)\n\t" \
                "mov %%edx,4(%0)\n\t" \
                "xor %%eax,%%eax\n\t" \
                "cpuid\n\t" \
                : /* no output */ \
                : "S"(&time) \
                : "eax", "ebx", "ecx", "edx", "memory")

#define read_rdtsc_after(time) \
        __asm__ __volatile__( \
                "xor %%eax,%%eax\n\t" \
                "cpuid\n\t" \
                "rdtsc\n\t" \
                "mov %%eax,(%0)\n\t" \
                "mov %%edx,4(%0)\n\t" \
                "xor %%eax,%%eax\n\t" \
                "cpuid\n\t" \
                : /* no output */ \
                : "S"(&time) \
                : "eax", "ebx", "ecx", "edx", "memory") 

#elif defined (__ia64)

#define rdtsc()                                               \
({ unsigned long long int x;                                   \
  __asm__ __volatile__("mov %0=ar.itc" : "=r"(x) :: "memory");\
  x; })
#define read_rdtsc_before(time) (time = rdtsc())
#define read_rdtsc_after(time)  (time = rdtsc())

#elif defined (__alpha)

#define rdtsc()                                   \
({ unsigned long long int x;                      \
   __asm__ volatile ("rpcc %0\n\t" : "=r" (x));   \
   x; })
#define read_rdtsc_before(time) (time = rdtsc())
#define read_rdtsc_after(time)  (time = rdtsc())

#else
# error Unsupported CPU
#endif

/* First loop : We do several measures and keep the minimum to avoid counting 
 * hardware interruption cycles.
 * Second loop: We do several measures until we are sure we are in the same
 * clock_t frame, so that we are sure no task switching has been done (removed s
ince it introduced problems with system call and empty cache). 
 * The filling of the CPU cache is done because we do several loops, and get the
 min.
 * Declaring num_cycle as "volatile" is to avoid optimisation when it is possibl
e (To properly calcul overhead).
 * overhead is calculated outside by a call to: overhead = MEASURE("overhead", ;
)
 * Use a lot the preprocessor.
 * It is a macro to be very flexible.
 */
static unsigned long long int overhead = 0;


#define NUM_TRY 4327
#define MEASURE(TEST) \
  ({ \
  volatile unsigned long long int num_cycle, num_cycle2, min_num_cycle; \
  int i_; \
  min_num_cycle = 0xFFFFFFFFFFFFFFFFLL; \
  for(i_ = 0 ; i_ < NUM_TRY ; i_++) \
    { \
          read_rdtsc_before(num_cycle); \
          TEST; \
          read_rdtsc_after(num_cycle2); \
          num_cycle =  num_cycle2 - num_cycle - overhead; \
      if (num_cycle < min_num_cycle) \
        min_num_cycle = num_cycle; \
    } \
  min_num_cycle; })

/*
 * It is few probable that an int triggers during the 2 calls of rdtsc
 * but it is possible (and it occurs too!).
 * But it is VERY unprobable that an int triggers for the minimum of 1000
 *  measures of the difference between 2 calls of rdtsc
 */ 
#define CALCUL_OVERHEAD (overhead = 0, overhead = MEASURE((void) 0) )

#endif

Puis pour utiliser:

{ 
 ...
 unsigned long long int t;

 CALCUL_OVERHEAD;

 t = measure (mafonction(x,y) );

[code]#elif defined (__TIGCC_ENV__)
#define rtdsc FiftyMSecTick[/code]


(C'est le plus précis qu'on a, le 68k n'a pas de compteur de cycles. )

On a plus précis, hein ^^ (qques 10aines de kHz je crois)

Tu peux augmenter la fréquence de l'AI5, mais à ce moment-là, FiftyMSecTick ira aussi plus vite vu que c'est branché sur l'AI5.

Pas sûr que l'AI5 de TI tienne le coup