dans le cadre d´un de mes programmes inutiles (en c-c++), j´aurais besoin d´un moyen de décompter avec précision des millisecondes (ou des centisecondes a la limite) pour faire un chronomètre

je connais la fonction time, qui décompte des secondes, mais voilà quoi, c´est pas assez précis

je compte sur vous pour m´aider

Tu as timeGetTime, précise au centième de seconde je crois, et sinon les QPF : QueryPerformanceFrequency.
Ils fonctionnent ainsi :

init du compteur de temps :
LONGLONG frq = NULL;
bool bRes = false;

bRes = QueryPerformanceFrequency((LARGE_INTEGER *) &frq);
if(bRes)
{
// Lecture du temps avec le compteur de performances
QueryPerformanceCounter((LARGE_INTEGER *) &t0);
ft = 1.0f/frq;
return(TRUE);
}
else
{
// Pb : afficher message d´erreur
}

voir le temps écoulé :

QueryPerformanceCounter((LARGE_INTEGER *)& t);
dt = (t-t0)*ft; // On multiplie par 0.001f pour passer de millisecondes à des secondes
t0 = t; // Le nouvel instant devient maintenant l´ancien, pour le futur calcul...

et le lib qui implémente ca est MMSYSTEM.H je crois bien.

Voilou, tu as tout je pense !
Bonne journée !

Pas besoin de MMSYSTEM.h, windows.h fera l´affaire.
Note que il faut utiliser setthreadaffinity pour etre sur que cela fonctionne sur toutes les configs.

justement, je suis en pleine découverte de la librairie windows.h

NON! Pourquoi ne pas utiliser les fonctions standards?

1. include <iostream>
2. include <cstdio>
3. include <ctime>

int main()
{
std::clock_t start;
double diff;

start = std::clock();
for ( int i = 0; i < 1000000; i++ )
printf ( "iamthwee" );
diff = ( std::clock() - start ) / (double)CLOCKS_PER_SEC;

std::cout<<"printf: "<< diff <<´\n´;
}

(chopée sur le net en 20 secondes)

Les fonctions standards n´ont pas une resolution tres grande, c´est parfais lorsqu´on veut faire des utilitaires se basant sur des dates, mais cela ne convient pas du tout aux real-time applications. Pour info, CLOCKS_PER_SEC vaut 1000 dans vs8...
Un lien interessant:
http://msdn2.microsoft.coom/en-us/library/bb173458.aspx

en plus avec le scaling des frequence des processeurs, et les horloges désynchronisés de certaines architectures multicoeur, je n´ai pas bien confiance dans ces techniques.

de quelles techniques parles-tu ?
les queryperformanceXXX fonctionnent tres bien si tu set le thread affinity tjs au meme core lors de leurs appels, et gerent les variations de frequence. C´est la seule facon "correcte" d´implementer un timing de nos jours sous windows.

je parlais de l´utilisation de clock. Il y a des architectres qui scale l´horloge avec la fréquence du CPU.

Sinon, a ce grain la (la millisecondes), on peut s´en sortir avec l´horloge classique qui est précise a la micro seconde (sous linux gettimeofday).

Si on veut etre plus précis, il faut descendre sur les compteurs matériel et la, ca devient beaucoup, beaucoup plus compliqué. Entre la migration de thread, le scaling des frequences, les horloges asynchrones des core1 (qui sont synchrones dans les core2 d´ailleurs)...

j´ai juste besoin d´une précision en millisecondes

en tout cas, les gars