Marca de tiempo en el lenguaje de programación C

Question

¿Cómo sello dos veces t1 y t2 y obtengo la diferencia en milisegundos en C?

Answer 1

Esto le dará el tiempo en segundos + microsegundos

#include <sys/time.h> 
struct timeval tv; 
gettimeofday(&tv,NULL); 
tv.tv_sec // seconds 
tv.tv_usec // microseconds 

Answer 2

Uso gettimeofday() o mejores clock_gettime()

Answer 3

U puede probar rutinas de biblioteca de tiempo de c (time.h). Además, eche un vistazo al clock() en la misma lib. Da los tics de reloj desde que el programa ha comenzado. Pero puede guardar su valor antes de la operación en la que desea concentrarse, y luego de esa operación capturar las marcas cliock nuevamente y encontrar la diferencia entre ellas para obtener la diferencia de tiempo. código

Answer 4

Uso @Arkaitz de Jiménez para obtener dos timevals: Código

#include <sys/time.h> 
//... 
struct timeval tv1, tv2, diff; 

// get the first time: 
gettimeofday(&tv1, NULL); 

// do whatever it is you want to time 
// ... 

// get the second time: 
gettimeofday(&tv2, NULL); 

// get the difference: 

int result = timeval_subtract(&diff, &tv1, &tv2); 

// the difference is storid in diff now. 

muestra para timeval_subtract se puede encontrar en this web site:

/* Subtract the `struct timeval' values X and Y, 
    storing the result in RESULT. 
    Return 1 if the difference is negative, otherwise 0. */ 

int 
timeval_subtract (result, x, y) 
     struct timeval *result, *x, *y; 
{ 
    /* Perform the carry for the later subtraction by updating y. */ 
    if (x->tv_usec < y->tv_usec) { 
    int nsec = (y->tv_usec - x->tv_usec)/1000000 + 1; 
    y->tv_usec -= 1000000 * nsec; 
    y->tv_sec += nsec; 
    } 
    if (x->tv_usec - y->tv_usec > 1000000) { 
    int nsec = (x->tv_usec - y->tv_usec)/1000000; 
    y->tv_usec += 1000000 * nsec; 
    y->tv_sec -= nsec; 
    } 

    /* Compute the time remaining to wait. 
     tv_usec is certainly positive. */ 
    result->tv_sec = x->tv_sec - y->tv_sec; 
    result->tv_usec = x->tv_usec - y->tv_usec; 

    /* Return 1 if result is negative. */ 
    return x->tv_sec < y->tv_sec; 
} 

Answer 5

Si usted quiere encontrar el tiempo transcurrido, este método funcionará siempre y cuando no reinicies la computadora entre el inicio y el final.

En Windows, use GetTickCount(). Así es como:

DWORD dwStart = GetTickCount(); 
... 
... process you want to measure elapsed time for 
... 
DWORD dwElapsed = GetTickCount() - dwStart; 

dwElapsed es ahora el número de milisegundos transcurridos.

En Linux, utilice reloj() y CLOCKS_PER_SEC hacer de la misma cosa.

Si necesita marcas de tiempo que duren por medio de reinicios o en PC (que en realidad necesitarían una sincronización bastante buena), utilice los otros métodos (gettimeofday()).

Además, en Windows al menos se puede conseguir mucho mejor que el tiempo de resolución estándar. Normalmente, si llamabas a GetTickCount() en un bucle cerrado, lo veías saltando 10-50 cada vez que cambiaba. Eso se debe al quantum de tiempo utilizado por el programador de subprocesos de Windows. Esta es más o menos la cantidad de tiempo que le da a cada hilo ejecutar antes de cambiar a otra cosa. Si lo hace un:

timeBeginPeriod(1); 

al comienzo de su programa o proceso y a:

timeEndPeriod(1); 

al final, entonces la cuántica cambiará a 1 ms, y obtendrá mucho mejor tiempo resolución en la llamada GetTickCount(). Sin embargo, esto crea un sutil cambio de la forma de todo el equipo ejecuta los procesos, así que tenlo en cuenta. Sin embargo, Windows Media Player y muchas otras cosas hacen de manera rutinaria de todos modos, así que no se preocupe demasiado acerca de él.

Estoy seguro de que hay alguna forma de hacer lo mismo en Linux (probablemente con mucho mejor control, o quizás con quantums de menos de milisegundos) pero no he necesitado hacerlo todavía en Linux.

Answer 6

estándar C99:

#include <time.h> 

time_t t0 = time(0); 
// ... 
time_t t1 = time(0); 
double datetime_diff_ms = difftime(t1, t0) * 1000.; 

clock_t c0 = clock(); 
// ... 
clock_t c1 = clock(); 
double runtime_diff_ms = (c1 - c0) * 1000./CLOCKS_PER_SEC; 

La precisión de los tipos es definido por la implementación, es decir, la diferencia de fecha y hora sólo se puede devolver segundos completos.

Answer 7

También tomando conciencia de las interacciones entre clock() y usleep(). usleep() suspende el programa y clock() solo mide el tiempo de ejecución del programa.

Si pudiera estar mejor utilizar gettimeofday() como se ha mencionado here

Answer 8

/* 
Returns the current time. 
*/ 

char *time_stamp(){ 

char *timestamp = (char *)malloc(sizeof(char) * 16); 
time_t ltime; 
ltime=time(NULL); 
struct tm *tm; 
tm=localtime(&ltime); 

sprintf(timestamp,"%04d%02d%02d%02d%02d%02d", tm->tm_year+1900, tm->tm_mon, 
    tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec); 
return timestamp; 
} 


int main(){ 

printf(" Timestamp: %s\n",time_stamp()); 
return 0; 

} 

de salida: Hora: 20110912130940 // 2011 Sep 12 13:09:40

Answer 9

¿qué hay de esta solución? No vi nada como esto en mi búsqueda. Estoy tratando de evitar la división y simplificar la solución.

struct timeval cur_time1, cur_time2, tdiff; 

    gettimeofday(&cur_time1,NULL); 
    sleep(1); 
    gettimeofday(&cur_time2,NULL); 

    tdiff.tv_sec = cur_time2.tv_sec - cur_time1.tv_sec; 
    tdiff.tv_usec = cur_time2.tv_usec + (1000000 - cur_time1.tv_usec); 

    while(tdiff.tv_usec > 1000000) 
    { 
     tdiff.tv_sec++; 
     tdiff.tv_usec -= 1000000; 
     printf("updated tdiff tv_sec:%ld tv_usec:%ld\n",tdiff.tv_sec, tdiff.tv_usec); 
    } 

    printf("end tdiff tv_sec:%ld tv_usec:%ld\n",tdiff.tv_sec, tdiff.tv_usec);