La medición de tiempo transcurrido en linux para un programa en c

Para empezar se necesita el uso de aritmética de punto flotante. Cualquier valor entero dividido por una mayor entero valor será cero, siempre.

Y, por supuesto, usted realmente debe hacer algo entre el inicio y el final de los tiempos.

Por cierto, si usted tiene acceso a gettimeofday normalmente se prefiere sobre clock ya que tiene mayor resolución. O tal vez clock_gettime que tiene mayor resolución.

Tres alternativas

1. clock()
2. gettimeofday()
3. clock_gettime()

clock_gettime() va hasta la precisión de nanosegundos, y apoya a los 4 relojes.

• CLOCK_REALTIME

  Todo el sistema de reloj de tiempo real. La configuración de este reloj requiere privilegios adecuados.

• CLOCK_MONOTONIC

  Reloj que no se puede establecer y representa monótona de tiempo, ya que algunos no especificado punto de partida.

• CLOCK_PROCESS_CPUTIME_ID

  De alta resolución de cada proceso temporizador de la CPU.

• CLOCK_THREAD_CPUTIME_ID

  Hilo específico de la CPU en tiempo de reloj.

Se puede utilizar como

#include <time.h>

struct timespec start, stop;

clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);

///do something

clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &stop);

double result = (stop.tv_sec - start.tv_sec) * 1e6 + (stop.tv_nsec - start.tv_nsec) / 1e3;    //in microseconds

Nota: El reloj() función que devuelve el tiempo de CPU para el proceso, no la hora del reloj de pared. Creo que esto es lo que el OP estaba interesado en. Si la hora del reloj de pared es la deseada, entonces gettimeofday() es una buena opción como se sugiere por una anterior respuesta. clock_gettime() puede hacer uno si su sistema admite; en mi linux embedded system clock_gettime() no es compatible, pero clock() y gettimeofday() son.

Siguiente es el código para obtener tiempo de reloj de pared utilizando gettimeofday()

#include <stdio.h> //for printf()
#include <sys/time.h> //for clock_gettime()
#include <unistd.h> //for usleep()

int main() {
    struct timeval start, end;
    long secs_used,micros_used;

    gettimeofday(&start, NULL);
    usleep(1250000); //Do the stuff you want to time here
    gettimeofday(&end, NULL);

    printf("start: %d secs, %d usecs\n",start.tv_sec,start.tv_usec);
    printf("end: %d secs, %d usecs\n",end.tv_sec,end.tv_usec);

    secs_used=(end.tv_sec - start.tv_sec); //avoid overflow by subtracting first
    micros_used= ((secs_used*1000000) + end.tv_usec) - (start.tv_usec);

    printf("micros_used: %d\n",micros_used);
    return 0;
}

Intentar Sunil D S la respuesta, pero el cambio de micros de unsigned long a tipo float o double, como este:

double micros;
float seconds;

clock_t start, end;

start = clock();

/* Do something here */

end = clock();

micros = end - start;
seconds = micros / 1000000;

Como alternativa, puede utilizar rusage, como este:

struct rusage before;

struct rusage after;

float a_cputime, b_cputime, e_cputime;

float a_systime, b_systime, e_systime;

getrusage(RUSAGE_SELF, &before);

/* Do something here! or put in loop and do many times */

getrusage(RUSAGE_SELF, &after);

a_cputime = after.ru_utime.tv_sec + after.ru_utime.tv_usec / 1000000.0;

b_cputime = before.ru_utime.tv_sec + before.ru_utime.tv_usec / 1000000.0;

e_cputime = a_cputime - b_cputime;

a_systime = after.ru_stime.tv_sec + after.ru_stime.tv_usec / 1000000.0;

b_systime = before.ru_stime.tv_sec + before.ru_stime.tv_usec / 1000000.0;

e_systime = a_systime - b_systime;


printf("CPU time (secs): user=%.4f; system=%.4f; real=%.4f\n",e_cputime, e_systime, seconds);

Unidades y la precisión dependerá de cuánto tiempo desea medir, pero cualquiera de estos debe
proporcionar una exactitud razonable para ms.

Cuando se divide, usted podría terminar con un decimal, por lo tanto, usted necesita un flaoting número de punto para almacenar el número de mili segundos.
Si usted no utiliza un punto flotante, la parte decimal se trunca. En su pieza de código, el inicio y el final son CASI los mismos. Por lo tanto el resultado, después de la división, cuando se almacena en un tiempo es «0».

unsigned long micros = 0;
float millis = 0.0;
clock_t start, end;

start = clock();

//code goes here

end = clock();

micros = end - start;
millis = micros / 1000;

Hay dos problemas con el código tal como está escrito.

1. Según man 3 clock, la resolución de clock() es en CLOCKS_PER_SEC incrementos por segundo. En un reciente-ish Cygwin sistema, es de 200. Basándose en los nombres de las variables, se espera que el valor de 1.000.000.

2. Esta línea:

   millis = micros / 1000;

   calculará el cociente como un entero, porque ambos operandos son enteros. La promoción a un tipo de punto flotante se produce en el momento de la asignación a millis, momento en el que la parte fraccionaria ya ha sido descartado.

Para calcular el número de segundos transcurridos utilizando clock(), usted necesita para hacer algo como esto:

clock_t start, end;
float seconds;
start = clock();
//Your code here:
end = clock();
seconds = end - start; //time difference is now a float
seconds /= CLOCKS_PER_SEC; //this division is now floating point

Sin embargo, es casi seguro que no se consigue una precisión de milisegundos. Para eso, usted tendrá que usar la gettimeofday() o clock_gettime(). Además, es probable que desee utilizar double en lugar de float, porque usted está probablemente va a terminar restar números muy grandes con una muy pequeña diferencia. El ejemplo que usa clock_gettime() sería:

#include <time.h>
/* Floating point nanoseconds per second */
#define NANO_PER_SEC 1000000000.0

int main(void)
{
    struct timespec start, end;
    double start_sec, end_sec, elapsed_sec;
    clock_gettime(CLOCK_REALTIME, &start);
    //Your code here
    clock_gettime(CLOCK_REALTIME, &end);
    start_sec = start.tv_sec + start.tv_nsec/NANO_PER_SEC;
    end_sec = end.tv_sec + end.tv_n_sec/NANO_PER_SEC;
    elapsed_sec = end_sec - start_sec;
    printf("The operation took %.3f seconds\n", elapsed_sec);
    return 0;
}

Desde NANO_PER_SEC es un valor de punto flotante, la división de operaciones se llevan a cabo en punto flotante.

Fuentes:

man páginas para clock(3), gettimeofday(3), y clock_gettime(3).

El C Programación Idioma, Kernighan y Ritchie