microsecond en C

voici un petit exemple de ce que je faisait quand je devait bencher une fonction...

#ifndef WIN32		// c-a-d sous linux
#define CLKTCK 1000000.0
#else			// sous windows
#define CLKTCK CLK_TCK
#endif
 
#include <time.h>
 
int main(int argc, char **argv)
{
 
// pour le bench
  int       n;
  clock_t  debut_programme;
  clock_t  fin_programme;
  double   duree_ecoulee;
 
  int      iter;
  double   temps[10];
  double   temps_moy = 0;
  double   temps_ect;
  double   sdt2 = 0;
  time_t t=time(0);
  struct tm* stm=localtime(&t);
 
  for (iter = 0; iter < 10; iter++)
  {
     debut_programme = clock ();
 
/* --- Bench --- */
     for (n = 0; n < 100; n++)
          fonction();
 
     fin_programme = clock ();
 
     duree_ecoulee = (double)fin_programme - (double)debut_programme;
     duree_ecoulee /= CLKTCK;
     duree_ecoulee /= 100;
     temps[iter] = duree_ecoulee;
  }
/* --- Statistiques --- */
  for (temps_moy = 0, sdt2 = 0, iter = 0; iter < 10; iter++)
  {
    temps_moy += temps[iter];
    sdt2 += (temps[iter] * temps[iter]);
  }
 
  temps_moy /= 10;
  temps_ect = sdt2 / 10.0 - (temps_moy * temps_moy);
  temps_ect = sqrt (temps_ect);
 
  fprintf (stderr,"fonction : Duree Moyenne =  %f : Ecart Type = %f \n",
	   temps_moy, temps_ect);
}

voila  

je te remercie pour ton aide,

mais j'ai une petite question concernant le programme.

Lancer 100 fois le bench te fait il gagner enormement en precision ou cela reste negligeable?

Le probleme est que pour des programmes au temps d'execution plutot long, ce cout engendre n'est pas negligeable  

Au fait comment obtiens tu CLKTCK sous linux? Je pense pas que se soit la vitesse de ton processeur car 1MHz ca me parait bien peu.

Merci d'avance.

le lancer 100 fois c'est parce que ton os est multi tache et donc il vaut mieux faire une moyenne des temps de manière a avoir une idée précise du temps que prend ta fonction

pour les fonction qui prennent du temps, je ne sais pas car mes fonctions benchée etait prévue pour etre implémentée sur un robot (donc du RT)

le CLK_TCK est une constante definie dans time.h et qui vaut 1000. Elle equivaut a un "tick" de la fonction clock(). la valeur sous linux a ete assez dur a trouver mais elle est juste comme ca  

PS : ce code est a compiler avec gcc  

PPS : je veux pas polémiquer mais voici ce que j'ai retire des mes bench :
Dans des condition semblables, linux est légèrement plus rapide que windows (voire nettement plus rapide) et il ets plus constant  

ok merci pour tout, je vais tester ca