Discussion :

[kingspy]

Bonjour tout le monde j'ai créé un serveur client UDP et pour effectue mes tests de performances, je me suis crée la classe Timer suivante.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
// file timer.h
// ********************************************************
// Timer class: For test perform
// ********************************************************
// On the STMicro platform, the time returned by GetTickCount
// includes a ~0.014% time drift, which is by design. This
// translates to a time lag of approximately 1s every 2h.
// The time will wrap around to zero if the system is run
// continuously for 49.7 days. msdn source.

#ifndef _TIMER_H_
#define _TIMER_H_

#define MAX_SAUV 100

#include <windows.h>

class Timer
{
public:
Timer()
{ for(int i = 0;i<MAX_SAUV;i++)
{
sauv[i]=0;
}
}

double T_Time(void)
{
return ((double)GetTickCount());
}

void T_Start(int i)
{ if(i<MAX_SAUV)
sauv[i]=GetTickCount();
}

double T_Stop(int i)
{
if(i<MAX_SAUV)
return ((double)(GetTickCount()-sauv[i]));
return 0;
}


DWORD sauv[MAX_SAUV];
};

#endif

/*************************************************
Et voici donc le main qui suit pour tester le dit timer:

int main()
{
Timer t;
double t1,t2,t3,t4;

t.T_Start(1);
Sleep(5);
t1=t.T_Stop(1);

t.T_Start(2);
Sleep(10);
t2=t.T_Stop(2);

t.T_Start(3);
Sleep(100);
t3=t.T_Stop(3);

t.T_Start(4);
Sleep(1000);
t4=t.T_Stop(4);

std::cout<<"Time: T1:"<<t1<<"ms T2:"<<t2<<"ms T3:"<<t3<<"ms T4:"<<t4<<"ms"<<std::endl;

return 0;
}

Maintenant le résultat plus qu'étrange :
Time: T1: 0ms T2: 15ms T3: 94ms T4: 1000ms

Quelqu'un peut il m'expliquer ?

Selon la doc msdn le gettick me revoit un temps en ms réinitialise tout les 49 jours.

Merci de votre lecture à défaut de réponses .

[Melem]

Je ne vois rien d'aberrant dans la sortie du programme. Seulement, GetTickCount (tout comme Sleep !) n'a pas la précision que penses qu'elle a. Pour faire des mesures plus précises utilise les Performance Counters (regarde dans les FAQ Win32 et C, c'est dans l'une ou l'autre ...) ou directement une instruction machine si tu peux inclure de l'assembleur dans ton code (genre rdtsc, etc.).

[kingspy]

Ok je te remercie, je vais regarder cela de suite. Aparament j ai ete trop confiant en lisant la doc msdn.

[ram-0000]

Pour avoir utilisé ces fonctions, je pense que c'est plutôt au niveau du Sleep qu'il y a des problèmes.

L'expérience m'a montré qu'un Sleep inférieur à 20 ms fait un peu n'importe quoi comme durée.

[kingspy]

Donc la solution se trouvait a porte de main

http://c.developpez.com/faq/index.ph...E_chronometrer

Effectivement, j avais tout d abord creer un thread qui comptait simplement des sleep(1); ce qui n etait pas terrible.
J ai tente le gettick qui ne fut pas mieux.

Donc pour avoir une reel precision QueryPerformanceCounter() dans l absolu c est 1/(feq proc). Sinon pour des precisions superieures 100ms je dirais gettick ou sleep.

Pour les feignants voici mon petit timer revu et corrige avec le nouveau resultat.

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
// ********************************************************
// file timer.h
// ********************************************************
//	Timer class: For test perform
// ********************************************************


#ifndef _TIMER_H_
#define _TIMER_H_

#define MAX_SAUV 10

#include <windows.h>

class Timer
{
public:
Timer()
{	
	QueryPerformanceFrequency(&freq);
}

double T_Time(void)
{	
	double t;
	LARGE_INTEGER tmp;

	QueryPerformanceCounter(&tmp);
	t = 1000.0 * tmp.QuadPart / freq.QuadPart;

	return t;
}

void T_Start(int i)
{	if(i<MAX_SAUV)
		QueryPerformanceCounter(&sauv[i]);
}

double T_Stop(int i)
{	LARGE_INTEGER end;
	double elapsed=0;

	QueryPerformanceCounter(&end);

	if(i<MAX_SAUV)
		elapsed = (1000.0 * (end.QuadPart - sauv[i].QuadPart)) / freq.QuadPart;
	
	return elapsed;
}

private:

LARGE_INTEGER sauv[MAX_SAUV],freq;

};

#endif

/*********************************************/
int main()
{	
Timer t;
double t1,t2,t3,t4;

t.T_Start(1);
Sleep(1);
t1=t.T_Stop(1);

t.T_Start(2);
Sleep(10);
t2=t.T_Stop(2);

t.T_Start(3);
Sleep(100);
t3=t.T_Stop(3);

t.T_Start(4);
Sleep(1000);
t4=t.T_Stop(4);

std::cout<<"Time: T1:"<<t1<<"ms T2:"<<t2<<"ms T3:"<<t3<<"ms T4:"<<t4<<"ms"<<std::endl;
}

Resultats tres explicites sur la validite du sleep et gettick:

Time: T1:1.8303ms T2:10.8637ms T3:100.457ms T4:1000.03ms


A bientot et bonne journee.

[Mac LAK]

Pour avoir utilisé ces fonctions, je pense que c'est plutôt au niveau du Sleep qu'il y a des problèmes.

Yep, GetTickCount est précis (à la milliseconde près, bien sûr) sur la plupart des machines, se méfier toutefois des fonctions d'économie d'énergie qui peuvent mettre un joyeux bordel là dedans.
Par contre, Sleep te garantit qu'il attendra au moins le temps passé en paramètre... Rien de plus.

Si en plus tu utilises des valeurs pour Sleep inférieures au quantum de temps par défaut des threads (10 à 40 ms habituellement, c'est vrai également pour la plupart des OS et ce n'est pas du tout spécifique à Windows), alors là tu vas direct au casse-pipe côté respect des chronos demandés... Autant faire un simple Sleep(0) ou un yield(), ça fera à peu près la même chose !!

Pour terminer, ta méthode (bien que parfaitement valide) renvoie un temps "réel", c'est à dire la durée d'exécution réelle d'un certain bout de code. Si jamais tu cherches à connaître la charge CPU utilisée par chaque bout de code, ta méthode ne peut pas marcher et il faut aller voir du côté de GetThreadTimes.