Il miglior metodo di cronometraggio in C?
https://stackoverflow.com/questions/459691
-
19-08-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Qual è il modo migliore per cronometrare una sezione di codice con alta risoluzione e portabilità?
/* Time from here */
ProcessIntenseFunction();
/* to here. */
printf("Time taken %d seconds %d milliseconds", sec, msec);
Esiste una libreria standard che avrebbe una soluzione multipiattaforma?
Soluzione
Penso che dovrebbe funzionare:
#include <time.h>
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);
Altri suggerimenti
gettimeofday () probabilmente farà quello che vuoi.
Se utilizzi hardware Intel, ecco come leggere il contatore delle istruzioni in tempo reale della CPU. Indica il numero di cicli della CPU eseguiti dall'avvio del processore. Questo è probabilmente il contatore ambientale più fine e più fine che puoi ottenere per la misurazione delle prestazioni.
Si noti che questo è il numero di cicli della CPU. Su Linux è possibile ottenere la velocità della CPU da / proc / cpuinfo e dividere per ottenere il numero di secondi. La conversione in doppio è abbastanza utile.
Quando eseguo questo sulla mia scatola, ottengo
11867927879484732 11867927879692217 it took this long to call printf: 207485
Ecco la Guida per sviluppatori Intel che fornisce tonnellate di dettagli.
#include <stdio.h>
#include <stdint.h>
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",y-x);
}
gettimeofday restituirà il tempo preciso ai microsecondi nella risoluzione di l'orologio di sistema. Potresti anche dare un'occhiata al progetto timer ad alta risoluzione su SourceForge.
Uso SDL_GetTicks dal libreria SDL .
Se non vuoi tempo CPU, penso che quello che stai cercando sia la struttura temporale.
Uso il seguente per calcolare il tempo di esecuzione:
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);
}
L'alta risoluzione è relativa ... Stavo guardando gli esempi e si occupano principalmente di millisecondi. Tuttavia per me è importante misurare i microsecondi. Non ho visto una soluzione indipendente dalla piattaforma per i microsecondi e ho pensato che sarebbe utile qualcosa come il codice qui sotto. Stavo programmando Windows solo per il momento e molto probabilmente aggiungerò un'implementazione gettimeofday () quando facevo lo stesso su AIX / Linux.
#ifdef WIN32
#ifndef PERFTIME
#include <windows.h>
#include <winbase.h>
#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
Utilizzo:
PERFTIME(ProcessIntenseFunction());
or
PERFTIME_INIT
PERFTIME_START
ProcessIntenseFunction()
PERFTIME_END
