Timmings sous Linux - Page 1

J'ai un petit probleme: je voudrais avoir un systeme de mesure fiable, et si possible precis afin de mesurer l'efficacite d'une fonction sous Linux.
J'ai deja trouve les fonctions clock (Peu precis, probleme avec plusieurs threads), cputime(idem), rdtsc(tres precis, mais seulement pour pentium et toujours problemes threads), et times(peu precis, mais pas de pb de thread).
Probleme de thread= du fait qu'il y ait plusieurs processus, cela perturbe la mesure.

Mais times n'est pas parfait: j'obtiens souvent des differences de 5% alors que rien ne change dans le code (pas de aleur aleatoire non plus).
C'est surement le cache du processeur qui entre en jeu, et des services supplementaires se declenchant et le vidant (ce qui ralentit l'execution du processus puisque je ne mesure que le temps utilisateur et que le cache du processeur a ete vide).

Des idees pour s'en sortir ?

Si possible, portable sous tout systeme Linux (alpha, x86, etc).

-

Il me semble que c'est le meme probleme que pour clock.

en gros tu cherches quoi ? un truc pour savoir combien de temps a duré l'execution d'une fonction ?

regarde du coté de gprof (le profiler GNU), il le fait comment ?

Pas mauvaise idee. D'ailleurs je m'en sers. Mais je voulais faire des bench precis.
"Bench precis" Une heresie sous Linux... Meme en comptant les temps utilisateurs seuls et en calculant les marges d'erreur due a la faible precision que l'on a, ben j'obtiens des variations de 5%. Surement due au cache du processeur et des services qui s'activent de facon aleatoire...

J'ai regarde. Gprof est plutot difficile a comprendre. Quelques coups de grep bien place, j'ai trouve qu'il utilise setitimer et getitimer de sys/times:

int getitimer(int which, struct itimerval *value);
int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue);

Toute ressemblance avec AMS ne serait pas fortruite...
Malheuresement, la resolution est de 10ms encore une fois (et c'est meme pas Posix) :

Timers will never expire before the requested time, instead expiring some short,
constant time afterwards, dependent on the system timer resolution (currently
10ms).

mais attend, si tu veux savoir la vitesse d'execution d'une fonction courte, tu la répliques 400000 fois, et tu mesures le temps avec plus de précision quand meme ...

Oui bien sur. Mais c'est pas si simple.

Suivant que je lance le bench matin midi ou soir (Le meme bench, les memes valeurs initiales), il ne me rendra pas les memes valeurs.
J'ai souvent des variations de 5 a 10%. Une fois a 100%, mais y'avait peut etre une erreur...

Bref, c'est la derme pour avoir des temps precis

-

man getrusage ?

Meme probleme et meme finesse que times.
Et je signales que je ne mesures que le temps passe dans le processus utilisateur et ne fais aucune entre/sortie suceptible de bloquer le processus.

Mais il a besoin de tous les services, le truc que tu veux bencher ? si c'est lançable en mode monoutilisateur, ça pourrait aider, non ? bon, évidemment, si c'est sous X...

J'ai pas acces au machine en temps que mono-utilisateur...
Vous croyez que j'ai des alpha, spark, power-pc, athlon, itanium a la maison ?

Euh pardon j'ai pas tout lu...

Remarque ca serait la solution...

Bon j'ai trouve une solution qui ne me satisafait qu'a moitie...
Ca ne marche que sous Pentium, mais au moins c'est precis.
Et il faut que la fonction a bencher soit pas trop longue... ou que le processeur soit tres rapide

  while (t1 != t2 && count < 100)
    {
      t1 = clock();
      // Be sure to fill corectly the CPU cache.
      // I don't know why it must done multiple times.
      TEST;
      TEST;
      TEST;
      TEST;

      num_cycle =rdtsc();
      // Start Bench.
      TEST;
      // Stop Bench

      num_cycle = rdtsc() - num_cycle;
      t2 = clock();
      count++;
    }
  printf("Result: %Lu\n", num_cycle);

avec la fonction:

 __inline__ unsigned long long int rdtsc()
 {
    unsigned long long int x;
    __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));     
    return x;  
 }

J'ai a 99% de chance d'obtenir la meme valeur.
Il reste toujours la possibilite d'une interruption materielle autre que le basculement de thread, qui rajoute quelques cycles. Mais c'est tres rare.

Parce qu'avec times, j'obtiens souvent des valeurs qui peuvent varier de 75% !

sous windows y'a la fonction getTickCount() qui est précise au 1 millionième de seconde près

Mais elle tient pas compte du basculement de thread...