Calculer une durée en millisecondes (en C)

[KewlCat]

Ah, pardon, je croyais que tu avais un exécutable par "algo" et que, comme ils faisaient le même traitement, tu aurais pu procéder avec time...

Cela dit, si tu peux isoler tes méthodes, et fabriquer un "vrai" benchmark (deux progs qui ne font QUE utiliser ces fonctions) tu pourras te rabattre sur time.

Eh mais... j'y pense... on doit bien avoir les sources de time qque part (bin oui, on est sous Linux !)... allez, je cherche ça !

[jeanbi]

Ne travaillant pas en C mais avec du VB et Delphi on se sert d'un timer donc la fonction donc bien exister en C

a+

[leneuf22]

Le timer de VB n'a rien à voir, par contre, il existe les fonctions SetTimer et KillTimer (user32.dll)

Mais elles ne vont pas au-dela des millisecondes.

[tangui]

je suis sur qu'il existe une fonction en C pour mesurer un temps en millisecondes...

du style gettickcount()

[jeanbi]

Voi ça

http://www.cppfrance.com/article.aspx?Val=949

je sais pas si cela peut t'aider

a+

[KewlCat]

tiens, c'est quoi ce truc ??

http://wwwos.inf.tu-dresden.de/~ch12/doc/d..._8c-source.html

 

bon, /usr/bin/time fait partie du package "bin" de al slackware, j'ai bon espoir de choper ses sources... sinon il est intégré au zsh, donc avec un peu de pot, dans les sources de zsh il va y avoir de quoi faire aussi...)

[Reika2000]

Je vous remercie tous de votre aide.

 

Je pourrais faire un binaire par méthode sans problème, mais le hic, c'est qu'il y a 2 partie dans chacune des méthodes, la construction puis la consultation d'un dictionnaire, et que je dois mesure ces 2 temps pour chacune des méthodes.

 

Jeanbi : le hic, c'est que ça utilise windows.h et que c'est du c++. Peut-être que ça existe aussi en C, je vais regarder, tant pis pour la portabilité, faut absolument que je rende des mesures.

 

Kewlcat : je vais approfondire tout ça demain (enfin aujourd'hui, mais après m'être couché).

[KewlCat]

J'ai sous les yeux les sources de zsh, et dans jobs.c tu retrouves la commande "time" (qui est intégrée au zsh, plutôt qu'externe... bref, passons)

Ils utilisent des struct timeval dans tous les coins...

Je continue la lecture, et je te dis comment ils procèdent...

[KewlCat]

C'est lourdingue à décoder, t'as plus de lignes pour la gestion des jobs et process que pour le calcul des temps...

void shelltime(void)

{       

   struct timeinfo ti;

   struct timezone dummy_tz;

   struct tms buf;

       

   times(&buf);

   ti.ut = buf.tms_utime;

   ti.st = buf.tms_stime;

   gettimeofday(&now, &dummy_tz);

   printtime(dtime(&dtimeval, &shtimer, &now), &ti, "shell");

   ti.ut = buf.tms_cutime;

   ti.st = buf.tms_cstime;

   printtime(dtime(&dtimeval, &shtimer, &now), &ti, "children");

} 

Les fameux struct tms utilisés sont des ensembles de clock_t (c'est dans linux/times.h), c'est à dire des long int (clock_t est défini dans bits/types.h)

C'est un vrai jeu de pistes...

Bon, maintenant je regarde ce qu'ils font avec times() et gettimeofday()

...

[KewlCat]

/* Store the CPU time used by this process and all its

  dead children (and their dead children) in BUFFER.

  Return the elapsed real time, or (clock_t) -1 for errors.

  All times are in CLK_TCKths of a second.  */

extern clock_t times (struct tms *__buffer) __THROW;

Eh bin voilà, de quoi mesurer le temps CPU et le temps "utilisateur" de tes méthodes...

Un times() au début, un times() à la fin, tu compares les deux et c'est gagné...

Voici comment ils ont procédé dans zsh :

/* Update status of process that we have just WAIT'ed for */



/**/

void

update_process(Process pn, int status)

{

   struct timezone dummy_tz;

   long childs, childu;



   childs = shtms.tms_cstime;

   childu = shtms.tms_cutime;

   times(&shtms);                          /* get time-accounting info          */



   pn->status = status;                    /* save the status returned by WAIT  */

   pn->ti.st  = shtms.tms_cstime - childs; /* compute process system space time */

   pn->ti.ut  = shtms.tms_cutime - childu; /* compute process user space time   */



   gettimeofday(&pn->endtime, &dummy_tz);  /* record time process exited        */

}

Et pour finir, voici comment ils règlent le problème de CLK_TCK

static void

set_clktck(void)

{

#ifdef _SC_CLK_TCK

   if (!clktck)

       /* fetch clock ticks per second from *

        * sysconf only the first time       */

       clktck = sysconf(_SC_CLK_TCK);

#else

# ifdef __NeXT__

   /* NeXTStep 3.3 defines CLK_TCK wrongly */

   clktck = 60;

# else          

#  ifdef CLK_TCK

   clktck = CLK_TCK;

#  else              

#   ifdef HZ

    clktck = HZ;

#   else

    clktck = 60;

#   endif        

#  endif

# endif 

#endif

} 

 

gettimeofday() utilise un struct timeval, mais je ne pense pas que ce soit ce qui nous interesse puisque le calcul de temps est effectué ci-dessus avec times()...