Estoy tratando de medir el tiempo transcurrido en Linux. Mi respuesta volviendo cero, lo que no tiene sentido para mí. A continuación es la manera de medir el tiempo en mi programa.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>

main()
{
    double p16 = 1, pi = 0, precision = 1000;
    int k;
    unsigned long micros = 0;
    float millis = 0.0;
    clock_t start, end;
    start = clock();
    //This section calculates pi
    for(k = 0; k <= precision; k++)
    {
        pi += 1.0 / p16 * (4.0 / (8 * k + 1) - 2.0 / (8 * k + 4) - 1.0 / (8 * k + 5) - 1.0 / (8 * k + 6));
        p16 *= 16;
    }
    end = clock();
    micros = end - start;
    millis = micros / 1000;
    printf("%f\n", millis); //my time keeps being returned as 0

    printf("this value of pi is  : %f\n", pi);
}
  • Supongo que te refieres a que el código está entre las llamadas a clock()
  • consulte cs.utah.edu/dept/old/texinfo/glibc-manual-0.02/library_19.html
  • Me acaba de actualizar el código para mostrar lo que está en entre dicho.El problema que estoy teniendo es el tiempo volviendo a 0
  • ¿qué acerca de la gnu time programa? o, alternativamente, el comando de bash time?
InformationsquelleAutor Jack welch | 2013-02-04

6 Comentarios

  1. 3

    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.

    • Gracias .Tendría cualquier enlace para getimeofday
    • no hay excusa para no utilizar el man de comandos en linux.
    • Actualizada la respuesta con enlaces a la función de las páginas de manual.
    • Si me pueden hacer una pregunta rápida.¿Cómo se puede medir el tiempo transcurrido en máquinas linux
    • Como hacer usted en su pregunta. Obtener el tiempo de inicio, hacer algo de trabajo, obtener el tiempo final, y calcular la diferencia. Las funciones reales y las estructuras implicadas en realidad no importa.
    • Todavía no funciona.Acabo de actualizar mi código de arriba.El tiempo pone cada vez devuelve 0
    • Sigue la división entera! Cambiar a millis = micros / 1000.0f;
    • usando bash, ejecutables puede ser programado con tiempo
    • como en el función o como comando de shell? Si la primera tiene a baja resolución, si el segundo es solo para todo el programa cuando se ejecuta en una consola y no para una parte de un programa.
    • Yo estaba pensando en la fiesta builtin, y realmente sólo en el contexto de ‘¿Cómo se puede medir el tiempo transcurrido en máquinas linux». Podría haber mencionado valgrind y/o gprof, supongo.

  2. 14

    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
  3. 6

    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;
    }
  4. 1

    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.

  5. 1

    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;
    • Todavía no funciona.Sigo recibiendo 0
    • Trate de usar el micro segundos. El código podría ser teniendo muy poco tiempo para ejecutar para que usted pueda medir en segundos.
  6. 0

    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

Dejar respuesta

Please enter your comment!
Please enter your name here