¿Cómo crear un temporizador de alta resolución en Linux para medir el rendimiento del programa?

Question

Estoy tratando de comparar la GPU con el rendimiento de la CPU. Para la GPU NVIDIA he estado utilizando los tipos cudaEvent_t para obtener un tiempo muy preciso.

Para la CPU He estado usando el siguiente código:

// Timers 
clock_t start, stop; 
float elapsedTime = 0; 

// Capture the start time 

start = clock(); 

// Do something here 
....... 

// Capture the stop time 
stop = clock(); 
// Retrieve time elapsed in milliseconds 
elapsedTime = (float)(stop - start)/(float)CLOCKS_PER_SEC * 1000.0f; 

Al parecer, ese trozo de código sólo es bueno si usted está contando en cuestión de segundos. Además, los resultados en algún momento resultan bastante extraños.

¿Alguien sabe de alguna manera para crear un temporizador de alta resolución en Linux?

Answer 1

Consulte clock_gettime, que es una interfaz POSIX para temporizadores de alta resolución.

Si, después de leer la página de manual, uno se queda preguntándose sobre la diferencia entre CLOCK_REALTIME y CLOCK_MONOTONIC, ve Difference between CLOCK_REALTIME and CLOCK_MONOTONIC?

consulte la siguiente página para un ejemplo completo: http://www.guyrutenberg.com/2007/09/22/profiling-code-using-clock_gettime/

Answer 2

clock_gettime(2)

Answer 3

struct timespec t; 
clock_gettime(CLOCK_REALTIME, &t); 

también hay CLOCK_REALTIME_HR, pero no estoy seguro si hace alguna diferencia ..

Answer 4

¿Le interesa el tiempo de pared (cuánto tiempo realmente pasa) o el ciclo (cuántos ciclos)? En el primer caso, debe usar algo como gettimeofday.

El temporizador de resolución más alta usa las instrucciones de ensamblaje RDTSC x86. Sin embargo, esto mide los tics del reloj, por lo que debe asegurarse de que el modo de ahorro de energía esté desactivado.

La página wiki para el CET da algunos ejemplos: http://en.wikipedia.org/wiki/Time_Stamp_Counter

Answer 5

para resumir la información presentada hasta el momento, estas son las dos funciones necesarias para las aplicaciones típicas.

#include <time.h> 

// call this function to start a nanosecond-resolution timer 
struct timespec timer_start(){ 
    struct timespec start_time; 
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start_time); 
    return start_time; 
} 

// call this function to end a timer, returning nanoseconds elapsed as a long 
long timer_end(struct timespec start_time){ 
    struct timespec end_time; 
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end_time); 
    long diffInNanos = (end_time.tv_sec - start_time.tv_sec) * (long)1e9 + (end_time.tv_nsec - start_time.tv_nsec); 
    return diffInNanos; 
} 

Aquí es un ejemplo de cómo utilizarlos para cronometrar el tiempo que toma para calcular la varianza de una lista de entrada.

struct timespec vartime = timer_start(); // begin a timer called 'vartime' 
double variance = var(input, MAXLEN); // perform the task we want to time 
long time_elapsed_nanos = timer_end(vartime); 
printf("Variance = %f, Time taken (nanoseconds): %ld\n", variance, time_elapsed_nanos); 

Answer 6

epoll IMPLEMENTACIÓN: https://github.com/ielife/simple-timer-for-c-language

uso como esto:

timer_server_handle_t *timer_handle = timer_server_init(1024); 
if (NULL == timer_handle) { 
    fprintf(stderr, "timer_server_init failed\n"); 
    return -1; 
} 
ctimer timer1; 
    timer1.count_ = 3; 
    timer1.timer_internal_ = 0.5; 
    timer1.timer_cb_ = timer_cb1; 
    int *user_data1 = (int *)malloc(sizeof(int)); 
    *user_data1 = 100; 
    timer1.user_data_ = user_data1; 
    timer_server_addtimer(timer_handle, &timer1); 

    ctimer timer2; 
    timer2.count_ = -1; 
    timer2.timer_internal_ = 0.5; 
    timer2.timer_cb_ = timer_cb2; 
    int *user_data2 = (int *)malloc(sizeof(int)); 
    *user_data2 = 10; 
    timer2.user_data_ = user_data2; 
    timer_server_addtimer(timer_handle, &timer2); 

    sleep(10); 

    timer_server_deltimer(timer_handle, timer1.fd); 
    timer_server_deltimer(timer_handle, timer2.fd); 
    timer_server_uninit(timer_handle);