bonjour,
je débute dans c et je sais pas comment calculer le temps d'exécution d'une fonction.. je pense qu'il faut faire un time() avant et un time() après et faire la différence des deux, mais je connais pas la syntaxe :-/
 
merci à tous ceux qui me répondront

 
la précision est de l'ordre de la seconde, c'est peu mais c'est standard. si tu veux chronométrer une fonction je te conseille de l'exécuter plusieurs fois (pour que le résultat ne soit pas faussé par un événement incongru) et de faire une moyenne (tu fais une boucle qui l'exécute 100fois (ou plus))  
 
 

Si rapide, on peut aussi utiliser GetTickCount() avant et après et calculer la différence mais la précision n'est pas absolue (y a # 16 ticks par seconde donc on n'atteint pas la ms précise).
 
Si on lance le prog entre deux ticks, y aussi une imprécision..

c'est surtout archi pas standard, meme pas POSIX, laisse tomber cette solution

sinon ta QueryPerformanceTimer qui est tres precis    

z'etes des pyshopates les gars, c'est une question sur le C pas sur l'API de windows (que je conchie d'ailleurs)

 
Très juste, j'avais pas pensé aux nunuxiens et à la portabilité. Sous DOS, je me sert d'une INT pour "compter" les ticks.

les gens perdent trop souvent de vue que le C a été développé pour etre un langage hautement performant et portable.
 
et meme si vos fonctions de vos differentes API marchent (qui de borland, qui de VS, etc...), si vous voulez que getoman s'en servent, mettez le en garde et donnez lui au moins le prototype.

 
c pas facile de faire une application 100% portable. au depart javais commence un ptit jeu en opengl, puis jme suis rendu compte a un moment que je devait oublier cette idee

sinon t'as aussi la solution de compter le nombre de fois par seconde ou l'écran est redessiné, par une petite interruption VBL en asm
 
je sors

bon, trève de plaisanterie.
tu peux aussi mesurer le temps à l'aide d'un logiciel appelé profiler.
l'avantage, c'est que tu n'as pas à coder la mesure du temps, et donc tu peux faire un truc plus portable.

ben il faut un soft en plus et compiler avec certaines options, tout depend de ce qu'on veut. mais le profiler est tres bon pour ca
 
 
pour gcc, compilez tous warnings a fond, en -ggdb -pg (et mettez pas les options de réductions de tailles pour windows). ensuite, executez une fois votre programme. reste plus qu'a faire un "gprof a.exe > report.txt"  

Quand je cherche à améliorer mon code, pour aller vite, souvent j'utilise une boucle pour répéter (un beep avant, un beep après) et ma montre pour mesurer le temps. C'est très portable, et sur le 486/100, on voit mieux la différence que sur un 1GHz .
 
Quand on est sur PC (pas Mac), on peut aussi reprogrammer temporairement un des compteurs du 8253 pour les écarts assez faibles. Mais c'est pas très versatile non plus.

Merci qui  

clock marche aussi, mais le résultat est changeant... c au moins aussi preci que time_t selon le committé ISO. et aussi precis que l'implémentation le peut.
 
donc c'est quelque part. mieux vaut utiliser les time_t qui son réutilisables par ailleurs

 
Arf Carbon_14, tu persistes avec ton histoire de 16 tick ...
Sous Win32, c'est révolu ca.
GetTickCount est precis a la ms près. Un simple test t'en convaincra.
 

 
Le mec n'a pas precise sous quel OS il bossait et s'il utilisais ou non les API Win32.
Si c'est le cas, cette solution est parfaitement acceptable vu qu'il ne recherche pas la portabilite.
De plus, mesurer le temps d'execution d'une boucle, c'est generalement lors de la phase de developpement, et donc sa ligne non standard va degager de la version finale. Selon moi même pour un prog qui se veut portable (mais qui est developpe sous Win32) cette solution est acceptable (si c'est bien pour du test de performance lors du developpement)
 

J'ai l'impression que sous Win2K/Xp, il n'y a plus d'ecart significatif entre le timer classique et le performance timer.
Sous 98 il y a rapidement un gros ecart, mais testé sous XP, je n'ai pas trouvé de difference ... !
 

 
Il me semble que c'est une bidouille reservee a DOS ca ... (mais non je te cherche pas )
 
Tout ca pour dire (une énième fois ) : sous quel OS tu es et quelle precision tu cherches ?
Au passage, cette question a été mainte fois traitee et doit facilement etre retrouvee via une recherche.

en précision pure, y'a pas mieux que d'utiliser l'instruction RDTSC qui retourne dans EDX:EAX un compteur 64 bits s'incrémentant avec l'horloge CPU.
 
C'est par cette technique que les fréquences CPU effectives sont mesurables au pouillième de khz près...
 
On peut controller avec le temps pris en cycles d'horloges cpu que prends une portion de code.
 
Le problème des autres approches est qu'il faut assez d'itérations devant le pas de mesure pour avoir n'importe quoi comme mesure....
 
(souvent les profilers utilisent RDTSC)

HelloWorld a écrit a écrit :   Arf Carbon_14, tu persistes avec ton histoire de 16 tick ... Sous Win32, c'est révolu ca. GetTickCount est precis a la ms près. Un simple test t'en convaincra.

 
Merci pour l'info. Faudra que je teste un jour. On a 4/5 des PCs de manips de physique et de spectro sous Win 3.1(1) . Obligé de rester "basique".
 
Faudrait plutôt que je me taise avec mes vieux trucs.

sinon je peux aussi vous parlez de sys/timeb.h et de ftime

carbon_14 a écrit a écrit :     Merci pour l'info. Faudra que je teste un jour. On a 4/5 des PCs de manips de physique et de spectro sous Win 3.1(1) . Obligé de rester "basique".   Faudrait plutôt que je me taise avec mes vieux trucs.

Pas des vieux trucs : les PC sous Win98SE, ça reste courant, mais on y trouve encore les ticks tous les 18,2 fois par seconde environ (pas 16, désolé ). Et je ne serais pas surpris que ce soit toujours le cas sous Windows Meuh. Par contre, c'est vrai que ça a disparu sous Windows NT/2000/XP.

Windows:
QueryPerformanceCounter, QueryPerformanceFrequency
 
Unix:
gettimeofday

J'oubliais. Pour pouvoir mesure le temps d'execution d'une fonction par rapport a d'autres parties du code, tu peux utiliser un Profiler. Il y en a un notemment a Visual C++..

linux -> times()
 
http://www.hmug.org/man/3/times.html
 
ou tout simplement times a.out