Melhor método de temporização em C?

Qual é a melhor maneira de cronometrar uma seção de código com alta resolução e portabilidade?

/* Time from here */ ProcessIntenseFunction(); /* to here. */ printf("Time taken %d seconds %d milliseconds", sec, msec); 

Existe uma biblioteca padrão que teria uma solução multi-plataforma?

    Eu acho que isso deve funcionar:

     #include  clock_t start = clock(), diff; ProcessIntenseFunction(); diff = clock() - start; int msec = diff * 1000 / CLOCKS_PER_SEC; printf("Time taken %d seconds %d milliseconds", msec/1000, msec%1000); 

    gettimeofday () provavelmente fará o que você quiser.

    Se você usa hardware da Intel, veja como ler o contador de instruções em tempo real da CPU. Ele informará o número de ciclos de CPU executados desde que o processador foi inicializado. Esse é provavelmente o menor contador de overhead que você pode obter para a medição de desempenho.

    Note que este é o número de ciclos da CPU. No linux você pode obter a velocidade da CPU de / proc / cpuinfo e dividir para obter o número de segundos. Converter isso em um duplo é bastante útil.

    Quando eu corro isso na minha checkbox, eu fico

     11867927879484732
     11867927879692217
     demorou tanto tempo para chamar printf: 207485
    

    Aqui está o guia do desenvolvedor da Intel que fornece muitos detalhes.

     #include  #include  inline uint64_t rdtsc() { uint32_t lo, hi; __asm__ __volatile__ ( "xorl %%eax, %%eax\n" "cpuid\n" "rdtsc\n" : "=a" (lo), "=d" (hi) : : "%ebx", "%ecx"); return (uint64_t)hi << 32 | lo; } main() { unsigned long long x; unsigned long long y; x = rdtsc(); printf("%lld\n",x); y = rdtsc(); printf("%lld\n",y); printf("it took this long to call printf: %lld\n",yx); } 

    gettimeofday retornará o tempo exato para microssegundos dentro da resolução do relógio do sistema. Você também pode querer verificar o projeto High Res Timers no SourceForge.

    Eu uso SDL_GetTicks da biblioteca SDL .

    Alta resolução é relativa … Eu estava olhando para os exemplos e eles servem principalmente para milissegundos. No entanto, para mim, é importante medir microssegundos. Eu não vi uma solução independente de plataforma por microssegundos e pensei que algo como o código abaixo seria útil. Eu estava cronometrando no Windows apenas por enquanto e provavelmente adicionaria uma implementação gettimeofday () ao fazer o mesmo no AIX / Linux.

      #ifdef WIN32 #ifndef PERFTIME #include  #include  #define PERFTIME_INIT unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; unsigned __int64 endTime; double timeDifferenceInMilliseconds; #define PERFTIME_START QueryPerformanceCounter((LARGE_INTEGER *)&startTime); #define PERFTIME_END QueryPerformanceCounter((LARGE_INTEGER *)&endTime); timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds); #define PERFTIME(funct) {unsigned __int64 freq; QueryPerformanceFrequency((LARGE_INTEGER*)&freq); double timerFrequency = (1.0/freq); unsigned __int64 startTime; QueryPerformanceCounter((LARGE_INTEGER *)&startTime); unsigned __int64 endTime; funct; QueryPerformanceCounter((LARGE_INTEGER *)&endTime); double timeDifferenceInMilliseconds = ((endTime-startTime) * timerFrequency); printf("Timing %fms\n",timeDifferenceInMilliseconds);} #endif #else //AIX/Linux gettimeofday() implementation here #endif 

    Uso:

     PERFTIME(ProcessIntenseFunction()); or PERFTIME_INIT PERFTIME_START ProcessIntenseFunction() PERFTIME_END 

    Se você não quer tempo de CPU, acho que o que você está procurando é a estrutura timeval.

    Eu uso o abaixo para calcular o tempo de execução:

     int timeval_subtract(struct timeval *result, struct timeval end, struct timeval start) { if (start.tv_usec < end.tv_usec) { int nsec = (end.tv_usec - start.tv_usec) / 1000000 + 1; end.tv_usec -= 1000000 * nsec; end.tv_sec += nsec; } if (start.tv_usec - end.tv_usec > 1000000) { int nsec = (end.tv_usec - start.tv_usec) / 1000000; end.tv_usec += 1000000 * nsec; end.tv_sec -= nsec; } result->tv_sec = end.tv_sec - start.tv_sec; result->tv_usec = end.tv_usec - start.tv_usec; return end.tv_sec < start.tv_sec; } void set_exec_time(int end) { static struct timeval time_start; struct timeval time_end; struct timeval time_diff; if (end) { gettimeofday(&time_end, NULL); if (timeval_subtract(&time_diff, time_end, time_start) == 0) { if (end == 1) printf("\nexec time: %1.2fs\n", time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f)); else if (end == 2) printf("%1.2fs", time_diff.tv_sec + (time_diff.tv_usec / 1000000.0f)); } return; } gettimeofday(&time_start, NULL); } void start_exec_timer() { set_exec_time(0); } void print_exec_timer() { set_exec_time(1); }