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

ver rendimiento sistema ubuntu

Question

Estoy tratando de comparar la GPU con el rendimiento de la CPU. Para la GPU NVIDIA he estado usando 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;

Aparentemente, ese pedazo de código solo es bueno si estás contando en segundos. Además, los resultados en algún momento resultan bastante extraños.

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

Answer 1

¿Estás interesado en el tiempo de pared (cuánto tiempo realmente pasa) o el conteo de ciclos (cuántos ciclos)? En el primer caso, debe usar algo como gettimeofday .

El temporizador de resolución más alta usa la instrucción 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 de TSC da algunos ejemplos: http://en.wikipedia.org/wiki/Time_Stamp_Counter

Answer 2

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

Si, después de leer la página de manual, se queda preguntándose sobre la diferencia entre CLOCK_REALTIME y CLOCK_MONOTONIC , consulte ¿ Diferencia entre CLOCK_REALTIME y CLOCK_MONOTONIC?

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

#include <iostream>
#include <time.h>
using namespace std;

timespec diff(timespec start, timespec end);

int main()
{
    timespec time1, time2;
    int temp;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time1);
    for (int i = 0; i< 242000000; i++)
        temp+=temp;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &time2);
    cout<<diff(time1,time2).tv_sec<<":"<<diff(time1,time2).tv_nsec<<endl;
    return 0;
}

timespec diff(timespec start, timespec end)
{
    timespec temp;
    if ((end.tv_nsec-start.tv_nsec)<0) {
        temp.tv_sec = end.tv_sec-start.tv_sec-1;
        temp.tv_nsec = 1000000000+end.tv_nsec-start.tv_nsec;
    } else {
        temp.tv_sec = end.tv_sec-start.tv_sec;
        temp.tv_nsec = end.tv_nsec-start.tv_nsec;
    }
    return temp;
}

Answer 3

Implementación de epoll: https://github.com/ielife/simple-timer-for-c-language

usar de esta manera:

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);

Answer 4

Para resumir la información presentada hasta ahora, estas son las dos funciones requeridas para 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í hay un ejemplo de cómo usarlos en el tiempo que tarda en 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 5

clock_gettime

Answer 6

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

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