probleme en QueryPerformanceCounter()

Le
wormlo0ock
salut
voila c'est mon premier post :p
je demande juste un peu d'aide à propos de
QueryPerformanceCounter()
la 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)
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être Windows
if (!QueryPerformanceFrequency((LARGE_INTEGER*)&Fwin)) return 0;
printf ("Frequence du compteur Windows = ");
AfficheFrequence (uint64_to_double(Fwin));

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

// Attend quelques itérations (10 000) du chronomètre Windows
do
{
QueryPerformanceCounter((LARGE_INTEGER*)&Twin_apres);
} while (Twin_apres-Twin_avant < 10000);

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

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

je demande pourquoi un uint64 marche trés bien pendant que le double
ne marche sachant que les deux sont de 64bit , si c'est une question
de codage merci de détailler la procédure
une dernière question un peu bête quelle est la différence 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épend de l'endian (ici ça marche sur Intel x86)
typedef uint32 uint64_32[2];
uint64_32 *hack = (uint64_32 *)&x;
double dbl;

dbl = (*hack)[1];
dbl *= 4294967296;
dbl += (*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
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Laurent
Le #23547631

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
wormlo0ock
Le #23547691
On 9 juil, 12:10, "Laurent"
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
Laurent
Le #23548371


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
wormlo0ock
Le #23548641
On 9 juil, 16:50, "Laurent"


>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
Publicité
Poster une réponse
Anonyme