Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

probleme en QueryPerformanceCounter()

4 réponses
Avatar
wormlo0ock
salut
voila c'est mon premier post :p
je demande juste un peu d'aide =E0 propos de
QueryPerformanceCounter()
la fonction accepte un LARGE_INTEGER * comme agrument quand je lui
envoie un double le r=E9sultat est faux (1.5643556 e -313#DEN) mais
quand je lui envoie un uint64 le r=E9sultat est juste (35476989 tours)
typedef unsigned _int64 uint64;
voila le code
]int LitFrequenceCpu (double* frequence)
{
uint64 Fwin;
uint64 Twin_avant, Twin_apres;
double Tcpu_avant, Tcpu_apres;
double Fcpu;

// Lit la frequence du chronom=EAtre Windows
if (!QueryPerformanceFrequency((LARGE_INTEGER*)&Fwin)) return 0;
printf ("Frequence du compteur Windows =3D ");
AfficheFrequence (uint64_to_double(Fwin));

// Avant
Tcpu_avant =3D RDTSC();
QueryPerformanceCounter((LARGE_INTEGER*)&Twin_avant);

// Attend quelques it=E9rations (10 000) du chronom=E8tre Windows
do
{
QueryPerformanceCounter((LARGE_INTEGER*)&Twin_apres);
} while (Twin_apres-Twin_avant < 10000);

// Apres
Tcpu_apres =3D RDTSC();
QueryPerformanceCounter((LARGE_INTEGER*)&Twin_apres);

// Calcule la fr=E9quence en MHz
Fcpu =3D (Tcpu_apres - Tcpu_avant);
Fcpu *=3D uint64_to_double(Fwin);
Fcpu /=3D uint64_to_double(Twin_apres - Twin_avant);
*frequence =3D Fcpu;
return 1;
}

je demande pourquoi un uint64 marche tr=E9s bien pendant que le double
ne marche sachant que les deux sont de 64bit , si c'est une question
de codage merci de d=E9tailler la proc=E9dure
une derni=E8re question un peu b=EAte quelle est la diff=E9rence exacte et
fondamentale entre double et uint 64 surtout pourquoi en MS visual C++
il nous faut un hack pour conevertir de uint64 vers double

double uint64_to_double (const uint64 x)
{
#if defined(_MSC_VER)
// Petit hack pour convertir du 64 bits en double
// Ce hack d=E9pend de l'endian (ici =E7a marche sur Intel x86)
typedef uint32 uint64_32[2];
uint64_32 *hack =3D (uint64_32 *)&x;
double dbl;

dbl =3D (*hack)[1];
dbl *=3D 4294967296;
dbl +=3D (*hack)[0];

return dbl;
#endif
}
pour tous le code voila le lien
http://haypo.developpez.com/article/frequence_cpu/frequence_cpu.c

et mercii les gars

4 réponses

Avatar
Laurent
a écrit dans le message de news:

salut
voila c'est mon premier post :p


j>e demande juste un peu d'aide à propos de
QueryPerformanceCounter()


l>a fonction accepte un LARGE_INTEGER * comme agrument quand je lui
envoie un double le résultat est faux (1.5643556 e -313#DEN) mais
quand je lui envoie un uint64 le résultat est juste (35476989 tours)



__int64 est un long long comme LARGE_INTEGER :
et un double n'a pas la meme précision ( 52 bits )

http://msdn.microsoft.com/en-us/library/aa383713(v=vs.85).aspx
Avatar
wormlo0ock
On 9 juil, 12:10, "Laurent" wrote:
a écrit dans le message de news:
salu t
>voila c'est mon premier post  :p

j>e demande juste un peu d'aide à propos de>QueryPerformanceCounter()

l>a fonction accepte un LARGE_INTEGER * comme agrument quand je lui

>envoie un double le résultat est faux (1.5643556 e -313#DEN) mais
>quand je lui envoie un uint64 le résultat est juste (35476989 tours)

 __int64 est un long long comme LARGE_INTEGER :
et un double n'a pas la meme précision ( 52 bits )

http://msdn.microsoft.com/en-us/library/aa383713(v=vs.85).aspx



dacc mais pourriez vous me donnez un exemple sur cette précision.
comment il n'ont pas la même précision ??
l'idée n'est pas encore clair pour moi
_int64 = 64bit
double aussi 64Bit donc ou est la différence (la précision ) ??
mercii encore pour la réponse
Avatar
Laurent
a écrit dans le message de news:


dacc mais pourriez vous me donnez un exemple sur cette précision.
comment il n'ont pas la même précision ??
l'idée n'est pas encore clair pour moi
_int64 = 64bit
double aussi 64Bit donc ou est la différence (la précision ) ??
mercii encore pour la réponse



La représentation des flottants est expliquée sur de nombreux sites, comme

http://en.wikipedia.org/wiki/Half_precision_floating-point_format
http://docs.sun.com/source/806-3568/ncg_goldberg.html#810
http://download.oracle.com/docs/cd/E19957-01/806-3568/ncg_goldberg.html
Avatar
wormlo0ock
On 9 juil, 16:50, "Laurent" wrote:
a crit dans le message de news:


>dacc mais pourriez vous me donnez un exemple sur cette pr cision.
>comment il n'ont pas la m me pr cision ??
>l'id e n'est pas encore clair pour moi
>_int64 = 64bit
>double aussi 64Bit donc ou est la diff rence (la pr cision ) ??
>mercii encore pour la r ponse

La repr sentation des flottants est expliqu e sur de nombreux sites, comm e

http://en.wikipedia.org/wiki/Half_precision_floating-point_formathttp://d ocs.sun.com/source/806-3568/ncg_goldberg.html#810http://download.oracle.com /docs/cd/E19957-01/806-3568/ncg_goldberg.html



merci Laurent j'ai li les document mais j'ai pas bien compris la
différence ce que je sais c'est que uint64 n’accepte pas de virgule
aussi pour le LARGE_INTEGER , on dira donc que le l'espace est
insuffisant pour que QueryPerformanceCounter() stock le résultat là
dedans ???
mercii de quelque indications de votre part stp