Comment utiliser QueryPerformanceCounter?

J'ai récemment décidé que je devais passer de l'utilisation des millisecondes aux microsecondes pour ma classe Timer, et après quelques recherches, j'ai décidé que QueryPerformanceCounter était probablement mon pari le plus sûr. (L'avertissement sur le fait Boost::Posixque cela peut ne pas fonctionner sur l'API Win32 m'a un peu découragé). Cependant, je ne sais pas vraiment comment le mettre en œuvre.

Ce que je fais, c'est appeler la GetTicks()fonction esque que j'utilise et l'attribuer à la startingTicksvariable de Timer . Ensuite, pour trouver le temps écoulé, je soustrais simplement la valeur de retour de la fonction de startingTicks, et lorsque je réinitialise le minuteur, je rappelle simplement la fonction et lui attribue startTicks. Malheureusement, d'après le code que j'ai vu, ce n'est pas aussi simple que d'appeler QueryPerformanceCounter(), et je ne suis pas sûr de ce que je suis censé passer comme argument.

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

int main()
{
    StartCounter();
    Sleep(1000);
    cout << GetCounter() <<"\n";
    return 0;
}

Ce programme devrait afficher un nombre proche de 1000 (Windows Sleep n'est pas aussi précis, mais il devrait être comme 999).

La StartCounter()fonction enregistre le nombre de graduations du compteur de performance dans la CounterStartvariable. La GetCounter()fonction renvoie le nombre de millisecondes depuis StartCounter()son dernier appel sous forme de double, donc si GetCounter()renvoie 0,001, cela fait environ 1 microseconde depuisStartCounter() son appel.

Si vous voulez que la minuterie utilise les secondes à la place, changez

PCFreq = double(li.QuadPart)/1000.0;

à

PCFreq = double(li.QuadPart);

ou si vous voulez des microsecondes, utilisez

PCFreq = double(li.QuadPart)/1000000.0;

Mais c'est vraiment une question de commodité puisqu'elle renvoie un double.

J'utilise ces définitions:

/** Use to init the clock */
#define TIMER_INIT \
    LARGE_INTEGER frequency; \
    LARGE_INTEGER t1,t2; \
    double elapsedTime; \
    QueryPerformanceFrequency(&frequency);


/** Use to start the performance timer */
#define TIMER_START QueryPerformanceCounter(&t1);

/** Use to stop the performance timer and output the result to the standard stream. Less verbose than \c TIMER_STOP_VERBOSE */
#define TIMER_STOP \
    QueryPerformanceCounter(&t2); \
    elapsedTime=(float)(t2.QuadPart-t1.QuadPart)/frequency.QuadPart; \
    std::wcout<<elapsedTime<<L" sec"<<endl;

Utilisation (parenthèses pour éviter les redéfinitions):

TIMER_INIT

{
   TIMER_START
   Sleep(1000);
   TIMER_STOP
}

{
   TIMER_START
   Sleep(1234);
   TIMER_STOP
}

Sortie de l'exemple d'utilisation:

1.00003 sec
1.23407 sec

En supposant que vous êtes sous Windows (si c'est le cas, vous devez marquer votre question comme telle!), Sur cette page MSDN vous pouvez trouver la source d'une HRTimerclasse C ++ simple et utile qui encapsule les appels système nécessaires pour faire quelque chose de très proche de ce dont vous avez besoin (il serait facile d'y ajouter une GetTicks()méthode, en particulier, pour faire exactement ce dont vous avez besoin).

Sur les plates-formes non Windows, il n'y a pas de fonction QueryPerformanceCounter, donc la solution ne sera pas directement portable. Cependant, si vous l'enveloppez dans une classe telle que celle mentionnée ci-dessus HRTimer, il sera plus facile de changer l'implémentation de la classe pour utiliser ce que la plate-forme actuelle est effectivement en mesure d'offrir (peut-être via Boost ou autre!).

Je voudrais étendre cette question avec un exemple de pilote NDIS sur l'obtention du temps. Comme on le sait, KeQuerySystemTime (imité sous NdisGetCurrentSystemTime) a une faible résolution au-dessus des millisecondes, et il existe certains processus comme les paquets réseau ou d'autres IRP qui peuvent avoir besoin d'un meilleur horodatage;

L'exemple est tout aussi simple:

LONG_INTEGER data, frequency;
LONGLONG diff;
data = KeQueryPerformanceCounter((LARGE_INTEGER *)&frequency)
diff = data.QuadPart / (Frequency.QuadPart/$divisor)

où le diviseur est 10 ^ 3 ou 10 ^ 6 selon la résolution requise.