Discussion :

[mathro]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[droggo]

Joe,

J'utilise QueryPerformanceCounter.

[gbdivers]

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 ?

[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.

[mathro]

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

[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

[Bousk]

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.

[mathro]

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????

[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.

[moldavi]

Bonjour.

As-tu essayé "QueryPerformanceCounter" ?

[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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[mathro]

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

[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.

[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.

[EtherOS]

Bonjour.

As-tu essayé "QueryPerformanceCounter" ?

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[JolyLoic]

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.

[moldavi]

Bonjour.

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 ?

[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...

[Joel F]

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)

[mathro]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}