Como usar QueryPerformanceCounter?

Recentemente, decidi que precisava mudar de milissegundos para microssegundos para minha classe Timer e, depois de alguma pesquisa, decidi que QueryPerformanceCounter é provavelmente minha aposta mais segura. (O aviso de Boost::Posixque pode não funcionar na API do Win32 me desanima). No entanto, não tenho certeza de como implementá-lo.

O que estou fazendo é chamar qualquer GetTicks()função esque que estou usando e atribuí-la à startingTicksvariável do temporizador . Em seguida, para descobrir a quantidade de tempo que passou, apenas subtraio o valor de retorno da função de startingTicks, e quando eu zero o cronômetro, chamo a função novamente e atribuo a ela os marcadores de início. Infelizmente, pelo código que vi, não é tão simples quanto chamar QueryPerformanceCounter()e não tenho certeza do que devo passar como argumento.

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

Este programa deve gerar um número próximo a 1000 (o Windows Sleep não é tão preciso, mas deve ser como 999).

A StartCounter()função registra o número de ticks que o contador de desempenho possui na CounterStartvariável. A GetCounter()função retorna o número de milissegundos desde que StartCounter()foi chamada pela última vez como um double, portanto, se GetCounter()retornar 0,001, já se passou cerca de 1 microssegundo desde que StartCounter()foi chamada.

Se você quiser que o cronômetro use segundos em vez disso, mude

PCFreq = double(li.QuadPart)/1000.0;

para

PCFreq = double(li.QuadPart);

ou se você quiser microssegundos, use

PCFreq = double(li.QuadPart)/1000000.0;

Mas realmente é uma questão de conveniência, pois retorna um duplo.

Eu uso estas definições:

/** 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;

Uso (colchetes para evitar redefinições):

TIMER_INIT

{
   TIMER_START
   Sleep(1000);
   TIMER_STOP
}

{
   TIMER_START
   Sleep(1234);
   TIMER_STOP
}

Resultado do exemplo de uso:

1.00003 sec
1.23407 sec

Supondo que você esteja no Windows (se estiver, você deve marcar sua pergunta como tal!), Nesta página do MSDN você pode encontrar a fonte de uma HRTimerclasse C ++ simples e útil que envolve as chamadas de sistema necessárias para fazer algo muito próximo do que você precisa (seria fácil adicionar um GetTicks()método a ele, em particular, para fazer exatamente o que você precisa).

Em plataformas não Windows, não há função QueryPerformanceCounter, portanto, a solução não será diretamente portátil. No entanto, se você envolvê-lo em uma classe como a mencionada acima HRTimer, será mais fácil mudar a implementação da classe para usar o que a plataforma atual é realmente capaz de oferecer (talvez via Boost ou qualquer outra coisa!).

Gostaria de estender esta questão com um exemplo de driver NDIS sobre como obter tempo. Como se sabe, KeQuerySystemTime (imitado em NdisGetCurrentSystemTime) tem uma resolução baixa acima de milissegundos, e existem alguns processos como pacotes de rede ou outros IRPs que podem precisar de um carimbo de data / hora melhor;

O exemplo é tão simples:

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

onde divisor é 10 ^ 3 ou 10 ^ 6 dependendo da resolução necessária.