Calcul du temps d'exécution avec une grande précision en c++

Version imprimable

Salut à tous,

Je réalise un programme en C++ sous windows 7 sur visual studio 2010 dans lequel j'ai besoin de calculer le temps d'éxécution avec une grande précision ( en millisecondes).

J'ai trouvé une façon de faire qui est la suivante
Code:

1 2 3 4 5 6 7 8 9 #include <ctime> ... temps_initial = clock (); . . . /* Partie du code à évaluer */ . . . temps_final = clock (); temps_cpu = (temps_final - temps_initial) / CLOCKS_PER_SEC * 1000; // millisecondes
mais qui ne donne pas le temps exact pour des petites instances; et en faisant l'exécution plusieurs fois du meme code il ne donne pas le meme temps .
Quelqu'un saurait-il s'il existe une autre manière en C++ de calculer le temps avec uen grande précision ?
Merci d'avance de votre réponse.:P

07/05/2013, 18h41
droggo

Joe,

J'utilise QueryPerformanceCounter. :)
07/05/2013, 19h25
gbdivers

Citation:

Envoyé par mathro

mais qui ne donne pas le temps exact pour des petites instances; et en faisant l'exécution plusieurs fois du meme code il ne donne pas le meme temps .
Quelqu'un saurait-il s'il existe une autre manière en C++ de calculer le temps avec uen grande précision ?

Je vais pas répondre à la question, mais j'ai une ou deux remarques...

Que le temps d'exécution ne soit pas parfaitement identique si tu lances plusieurs fois ton application, c'est normal

En conséquence, vouloir améliorer la précision des compteurs n'est pas forcement possible

Tu veux faire quoi exactement ?
07/05/2013, 19h26
JolyLoic

QueryPerformanceCounter + QueryPerformanceFrequency si on veut afficher une durée en s.
Mais quoi qu'il arrive, que l'on ait des temps différents est normal, il y a tant de choses qui se passent sans cesse sur une machine...

Généralement, pour faire des benchs, je répète un grand nombre de fois l'opération à mesurer, jusqu'à ce que le temps total soit visible à l’œil nu (quelques secondes au moins).

En suite, je répète toutes mes mesures deux fois, et si je n'ai pas des valeurs suffisamment proches, je recommence tout, éventuellement en modifiant ce que je mesure.
07/05/2013, 19h32
mathro

Citation:

Envoyé par gbdivers

Je vais pas répondre à la question, mais j'ai une ou deux remarques...

En conséquence, vouloir améliorer la précision des compteurs n'est pas forcement possible

Tu veux faire quoi exactement ?

Mon application s'exécute en 0.56 s mais le programme m'affice dès fois 3s des fois 4s des fois 2s je veux qu'il m'affiche 0:00:00.56
07/05/2013, 19h40
gbdivers

C'est vrai que ça fait beaucoup de variation. Mais le problème vient pas du compteur et encore moins de sa précision. Voir ton code, faire du profiling, etc
07/05/2013, 19h50
Bousk

Citation:

Envoyé par gbdivers

C'est vrai que ça fait beaucoup de variation. Mais le problème vient pas du compteur et encore moins de sa précision. Voir ton code, faire du profiling, etc

Ou tout simplement la machine.
Lancement d'un autre logiciel, scan d'un fichier, ...... pendant l'exécution.
07/05/2013, 20h05
mathro

Citation:

Envoyé par Bousk

Ou tout simplement la machine.
Lancement d'un autre logiciel, scan d'un fichier, ...... pendant l'exécution.

quand j'exécute il ya que la fenetre de l'exécutable qui marche, mais là je trouve une grande déffirence de 0.56s à 3 -4 seconde, meme en faisant l'exécution à pluisuers reprise j'ai jamais eu quelque chose de 0.5 ou 0.9 s toujours plus de 2s, est ce que ya pas une façon de minimiser cette différence????
08/05/2013, 00h10
minnesota

Salut,

Il faut lancer ton processus ou la portion de code que tu analyses avec une priorité haute, de la sorte, le temps d'exécution dépendra plus de ton code que du temps processeur que le système aura "bien voulu" t'accorder en priorité normale.

Il faut aussi penser à désactiver ton antivirus le temps de l'opération.
08/05/2013, 00h39
moldavi

Bonjour.

As-tu essayé "QueryPerformanceCounter" ?
08/05/2013, 00h43
backlash
Passe sous un système UNIX, où tu peux obtenir le temps que ton processus passe en user mode et en kernel mode grace à l'appel systèmes certifié POSIX :
Code:

1 2 #include <sys/times.h> clock_t times(struct tms *buf );
La somme de ces 2 durées te donnent ainsi la durée totale d'exécution de ton processus sans prendre en compte les durées de préemption.
08/05/2013, 01h43
mathro

Citation:

Envoyé par moldavi

Bonjour.

As-tu essayé "QueryPerformanceCounter" ?

Oui j'ai inclu "QueryPerformanceCounter" et j'avais des temps plus précis par exemple 3125.46 millisecondes donc c'est beacoup mieux que avant
08/05/2013, 10h30
r0d

boost::chrono ne serait-il pas plus approprié ici?
C'est portable, précis, il y a les notions de "time_point" et de "duration" qui sont très pratiques pour toutes les manipulations et les transformations en diverses unités de temps sont triviales.
09/05/2013, 07h55
Joel F

faut aussi faire plusieurs run et en prendre la mediane (si on veut le temps le plus plausible) ou le minimum (si on veut le temps optimal). Evitez la moyenne des runs, les benchs n'etant pas des variables aleatoires mais des series a longues traines.

Sous linux, y a aussi les timer temps reel que boost.chrono encapsule.

pour mieux éclaircir ?

Citation:

Envoyé par moldavi

Bonjour.

As-tu essayé "QueryPerformanceCounter" ?

Pour mieux t'éclaircir tu peux faire comme suit :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>
#include <windows.h>

using namespace std;

int main()
{
	LONGLONG Freq;
	LONGLONG Now;
	LONGLONG Last;
	QueryPerformanceFrequency ( reinterpret_cast<LARGE_INTEGER*>(&Freq) );
	QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>(&Last) );
	Sleep(10); // pause for 10 mills

	while(1)
	{
		QueryPerformanceCounter( reinterpret_cast<LARGE_INTEGER*>(&Now) );
		LONGLONG EclapsedCount = Now - Last;
		LONGLONG TimerResolution = 1000; //en Millisecondes
		LONGLONG Millisecondes = EclapsedCount * TimerResolution / Freq;
		cout << "Run speed: " << Millisecondes << " millisecons" << endl;
		Last = Now;

		Sleep(10);
	}
	cout << "voici un exemple juste pour t'aider" << endl;
	return 0;
}

09/05/2013, 18h05
JolyLoic

Citation:

Envoyé par Joel F

faut aussi faire plusieurs run et en prendre la mediane (si on veut le temps le plus plausible) ou le minimum (si on veut le temps optimal). Evitez la moyenne des runs, les benchs n'etant pas des variables aleatoires mais des series a longues traines.

Je suis globalement d'accord avec toi que la médiane ou le minimum sont de meilleures mesures que la moyenne pour un test de performances, le problème est qu'elles obligent à mesurer le temps individuellement, là où la moyenne permet de ne faire qu'une mesure de temps pour toute une répétition de calculs.

Pour des petits calculs très rapides, je préfère donc faire plusieurs calculs de moyenne. Maintenant, pour des opérations plus longues, où le temps de mesure devient négligeable, je suis d'accord avec toi.
10/05/2013, 00h15
moldavi

Bonjour.

Citation:

Envoyé par EtherOS

Pour mieux t'éclaircir tu peux faire comme suit :

Etes-vous certain que ce message s'adresse à moi... Ou alors ma citation est juste là pour appuyer votre raisonnement ?
10/05/2013, 01h42
Klaim

Personellement je prefere utilise Boost.Chrono pour les mesures, avec l'horloge adequqte:

- std::chrono ne peut pas garantir que l'implementation va etre suffisament precise, par exemple VC11 et VC12(qui n'est pas encore sorti) ont une precison de 8ms ce qui est enorme et impossible a utilser dans certains cas;
- boost::chrono est tres precis parcequ'il utilise QueryPerformanceCounter avec l'horloge haute precision;
- boost::chrono est suppose precis sur les platforms derivees d'unix aussi mais j'ai pas teste;

Apres, faut avoir boost de pret dans une coin aussi...
12/05/2013, 12h34
Joel F

Citation:

Envoyé par JolyLoic

Je suis globalement d'accord avec toi que la médiane ou le minimum sont de meilleures mesures que la moyenne pour un test de performances, le problème est qu'elles obligent à mesurer le temps individuellement, là où la moyenne permet de ne faire qu'une mesure de temps pour toute une répétition de calculs.

Pour des petits calculs très rapides, je préfère donc faire plusieurs calculs de moyenne. Maintenant, pour des opérations plus longues, où le temps de mesure devient négligeable, je suis d'accord avec toi.

Disons que en general ca passe. Faut que je retrouve le papier sur le sujet ou le gars exhibeun programme C de 15 lignes completement anodin ou la moyenne du temps d'execution est en O(nb de run)

Citation:

Envoyé par Bousk

Ou tout simplement la machine.
Lancement d'un autre logiciel, scan d'un fichier, ...... pendant l'exécution.

En effet je dispose de deux exécutable, le miens et un autre, je fait l'éxécution en meme temps sur la meme machine, le mien se termine avant l'autre mais le temps d'exécution affiché par mon exécutable est 3.14 seconde et l'autre exécutable affiche 0.22 seconde!!!! donc voilà une grande différence :?
PS: je dispose pas du code source de l'autre exécutable donc je peux pas voir qu'est ce qu'il a utiliser comme fonction pour le calcul du temps.

Voilà ce que j'utilise actuellment pour calculer le temps
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include <windows.h> double PCFreq = 0.0; __int64 CounterStart = 0; void StartCounter() { LARGE_INTEGER li; if(!QueryPerformanceFrequency(&li)) cout << "QueryPerformanceFrequency failed!\n"; PCFreq = double(li.QuadPart)/1000.0; QueryPerformanceCounter(&li); CounterStart = li.QuadPart; } double GetCounter() { LARGE_INTEGER li; QueryPerformanceCounter(&li); return double(li.QuadPart-CounterStart)/PCFreq; } void main() { StartCounter(); ............. temps=GetCounter(); cout<<"Temps d'execution "<<temps<<" millisecondes"<<endl; }