Tiempo de ejecución del programa C

Tengo un programa en C que pretende ejecutarse en paralelo en varios procesadores. Necesito poder registrar el tiempo de ejecución (que puede ser de 1 segundo a varios minutos). He buscado respuestas, pero todas parecen sugerir el uso de la clock()función, que luego implica calcular el número de relojes que tomó el programa dividido por el Clocks_per_secondvalor.

¿No estoy seguro de cómo Clocks_per_secondse calcula el valor?

En Java, solo tomo el tiempo actual en milisegundos antes y después de la ejecución.

¿Hay algo similar en C? He echado un vistazo, pero parece que no puedo encontrar una manera de obtener algo mejor que una segunda resolución.

También sé que un perfilador sería una opción, pero estoy buscando implementar un temporizador yo mismo.

Gracias

CLOCKS_PER_SECes una constante que se declara en <time.h>. Para obtener el tiempo de CPU utilizado por una tarea dentro de una aplicación C, use:

clock_t begin = clock();

/* here, do your time-consuming job */

clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;

Tenga en cuenta que esto devuelve el tiempo como un tipo de punto flotante. Esto puede ser más preciso que un segundo (por ejemplo, mide 4.52 segundos). La precisión depende de la arquitectura; en sistemas modernos, obtiene fácilmente 10 ms o menos, pero en máquinas Windows más antiguas (de la era Win98) estaba más cerca de 60 ms.

clock()es el estándar C; funciona "en todas partes". Hay funciones específicas del sistema, comogetrusage() en sistemas tipo Unix.

Java System.currentTimeMillis()no mide lo mismo. Es un "reloj de pared": puede ayudarlo a medir cuánto tiempo le llevó ejecutar el programa, pero no le dice cuánto tiempo de CPU se utilizó. En un sistema multitarea (es decir, todos ellos), estos pueden ser muy diferentes.

Si está utilizando el shell de Unix para ejecutar, puede usar el comando time.

haciendo

$ time ./a.out

suponiendo a.out como el ejecutable le dará el tiempo necesario para ejecutar esto

En vainilla simple C:

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

int main()
{
    clock_t tic = clock();

    my_expensive_function_which_can_spawn_threads();

    clock_t toc = clock();

    printf("Elapsed: %f seconds\n", (double)(toc - tic) / CLOCKS_PER_SEC);

    return 0;
}

Funcionalmente quieres esto:

#include <sys/time.h>

struct timeval  tv1, tv2;
gettimeofday(&tv1, NULL);
/* stuff to do! */
gettimeofday(&tv2, NULL);

printf ("Total time = %f seconds\n",
         (double) (tv2.tv_usec - tv1.tv_usec) / 1000000 +
         (double) (tv2.tv_sec - tv1.tv_sec));

Tenga en cuenta que esto mide en microsegundos, no solo segundos.

La mayoría de los programas simples tienen tiempo de cálculo en milisegundos. Entonces, supongo, esto lo encontrará útil.

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

int main(){
    clock_t start = clock();
    // Execuatable code
    clock_t stop = clock();
    double elapsed = (double)(stop - start) * 1000.0 / CLOCKS_PER_SEC;
    printf("Time elapsed in ms: %f", elapsed);
}

Si desea calcular el tiempo de ejecución de todo el programa y está en un sistema Unix, ejecute su programa usando el comando de tiempo como estetime ./a.out

Se han sugerido muchas respuestas clock()y luego CLOCKS_PER_SECde time.h. Probablemente sea una mala idea, porque esto es lo /bits/time.hque dice mi archivo:

/* ISO/IEC 9899:1990 7.12.1: <time.h>
The macro `CLOCKS_PER_SEC' is the number per second of the value
returned by the `clock' function. */
/* CAE XSH, Issue 4, Version 2: <time.h>
The value of CLOCKS_PER_SEC is required to be 1 million on all
XSI-conformant systems. */
#  define CLOCKS_PER_SEC  1000000l

#  if !defined __STRICT_ANSI__ && !defined __USE_XOPEN2K
/* Even though CLOCKS_PER_SEC has such a strange value CLK_TCK
presents the real value for clock ticks per second for the system.  */
#   include <bits/types.h>
extern long int __sysconf (int);
#   define CLK_TCK ((__clock_t) __sysconf (2))  /* 2 is _SC_CLK_TCK */
#  endif

Por CLOCKS_PER_SEClo tanto, podría definirse como 1000000, dependiendo de las opciones que use para compilar, por lo que no parece una buena solución.

La respuesta de Thomas Pornin como macros:

#define TICK(X) clock_t X = clock()
#define TOCK(X) printf("time %s: %g sec.\n", (#X), (double)(clock() - (X)) / CLOCKS_PER_SEC)

Úselo así:

TICK(TIME_A);
functionA();
TOCK(TIME_A);

TICK(TIME_B);
functionB();
TOCK(TIME_B);

Salida:

time TIME_A: 0.001652 sec.
time TIME_B: 0.004028 sec.

Debe tener en cuenta que medir el tiempo que tardó un programa en ejecutarse depende mucho de la carga que tenga la máquina en ese momento específico.

Sabiendo que, la forma de obtener el tiempo actual en C se puede lograr de diferentes maneras, una más fácil es:

#include <time.h>

#define CPU_TIME (getrusage(RUSAGE_SELF,&ruse), ruse.ru_utime.tv_sec + \
  ruse.ru_stime.tv_sec + 1e-6 * \
  (ruse.ru_utime.tv_usec + ruse.ru_stime.tv_usec))

int main(void) {
    time_t start, end;
    double first, second;

    // Save user and CPU start time
    time(&start);
    first = CPU_TIME;

    // Perform operations
    ...

    // Save end time
    time(&end);
    second = CPU_TIME;

    printf("cpu  : %.2f secs\n", second - first); 
    printf("user : %d secs\n", (int)(end - start));
}

Espero eso ayude.

¡Saludos!

(Faltan todas las respuestas aquí, si su administrador del sistema cambia la hora del sistema, o si su zona horaria tiene diferentes horarios de invierno y verano. Por lo tanto ...)

Sobre el uso de Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); no se ve afectado si el administrador del sistema cambia la hora, o si vives en un país con un horario de invierno diferente del horario de verano, etc.

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

#include <unistd.h> /* for sleep() */

int main() {
    struct timespec begin, end;
    clock_gettime(CLOCK_MONOTONIC_RAW, &begin);

    sleep(1);      // waste some time

    clock_gettime(CLOCK_MONOTONIC_RAW, &end);

    printf ("Total time = %f seconds\n",
            (end.tv_nsec - begin.tv_nsec) / 1000000000.0 +
            (end.tv_sec  - begin.tv_sec));

}

man clock_gettime estados:

CLOCK_MONOTONIC
              Clock  that  cannot  be set and represents monotonic time since some unspecified starting point.  This clock is not affected by discontinuous jumps in the system time
              (e.g., if the system administrator manually changes the clock), but is affected by the incremental adjustments performed by adjtime(3) and NTP.

ANSI C solo especifica funciones de tiempo de segunda precisión. Sin embargo, si está ejecutando en un entorno POSIX, puede usar gettimeofday () que proporciona una resolución de microsegundos del tiempo transcurrido desde la época de UNIX.

Como nota al margen, no recomendaría usar clock () ya que está mal implementado en muchos sistemas (¿si no todos?) Y no es preciso, además del hecho de que solo se refiere a cuánto tiempo ha pasado su programa en la CPU y no la duración total del programa, que según su pregunta es lo que supongo que le gustaría medir.

Todas las soluciones no funcionan en mi sistema.

Puedo empezar a usar

#include <time.h>

double difftime(time_t time1, time_t time0);

    #include<time.h>
    #include<stdio.h>
    int main(){
clock_t begin=clock();

    int i;
for(i=0;i<100000;i++){
printf("%d",i);

}
clock_t end=clock();
printf("Time taken:%lf",(double)(end-begin)/CLOCKS_PER_SEC);
}

Este programa funcionará a las mil maravillas.

He encontrado que el reloj habitual (), todos lo recomiendan aquí, por alguna razón se desvía enormemente de una ejecución a otra, incluso para el código estático sin efectos secundarios, como dibujar en la pantalla o leer archivos. Podría ser porque la CPU cambia los modos de consumo de energía, el sistema operativo le da diferentes prioridades, etc.

Por lo tanto, la única forma de obtener el mismo resultado de manera confiable cada vez con clock () es ejecutar el código medido en un bucle varias veces (durante varios minutos), tomando precauciones para evitar que el compilador lo optimice: los compiladores modernos pueden calcular previamente el código sin los efectos secundarios que se ejecutan en un bucle, y moverlo fuera del bucle., por ejemplo, usando una entrada aleatoria para cada iteración.

Después de recolectar suficientes muestras en una matriz, se ordena esa matriz y se toma el elemento central, llamado mediana. La mediana es mejor que la media, ya que arroja desviaciones extremas, como decir que el antivirus ocupa toda la CPU o el sistema operativo haciendo alguna actualización.

Aquí hay una sencilla utilidad para medir el rendimiento de ejecución del código C / C ++, promediando los valores cercanos a la mediana: https://github.com/saniv/gauge

Todavía estoy buscando una forma más robusta y rápida de medir el código. Probablemente se podría intentar ejecutar el código en condiciones controladas en el metal desnudo sin ningún sistema operativo, pero eso dará un resultado poco realista, porque en realidad el sistema operativo se involucra.

x86 tiene estos contadores de rendimiento de hardware, que incluyen el número real de instrucciones ejecutadas, pero son difíciles de acceder sin ayuda del sistema operativo, difíciles de interpretar y tienen sus propios problemas ( http://archive.gamedev.net/archive/reference/articles /article213.html ). Aún así, podrían ser útiles para investigar la naturaleza del cuello de la botella (acceso a datos o cálculos reales sobre esos datos).

Algunos podrían encontrar útil un tipo diferente de información: me dieron este método de medición del tiempo como parte de un curso universitario sobre programación GPGPU con NVidia CUDA ( descripción del curso ). Combina métodos vistos en publicaciones anteriores, y simplemente lo publico porque los requisitos le dan credibilidad:

unsigned long int elapsed;
struct timeval t_start, t_end, t_diff;
gettimeofday(&t_start, NULL);

// perform computations ...

gettimeofday(&t_end, NULL);
timeval_subtract(&t_diff, &t_end, &t_start);
elapsed = (t_diff.tv_sec*1e6 + t_diff.tv_usec);
printf("GPU version runs in: %lu microsecs\n", elapsed);

Supongo que podría multiplicarse con, por ejemplo, 1.0 / 1000.0para obtener la unidad de medida que se adapte a sus necesidades.

Comparación del tiempo de ejecución del ordenamiento de burbujas y el ordenamiento de selección Tengo un programa que compara el tiempo de ejecución del ordenamiento de burbujas y el ordenamiento de selección. Para averiguar el tiempo de ejecución de un bloque de código, calcule el tiempo antes y después del bloque por

 clock_t start=clock();
 …
 clock_t end=clock();
 CLOCKS_PER_SEC is constant in time.h library

Código de ejemplo:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
   int a[10000],i,j,min,temp;
   for(i=0;i<10000;i++)
   {
      a[i]=rand()%10000;
   }
   //The bubble Sort
   clock_t start,end;
   start=clock();
   for(i=0;i<10000;i++)
   {
     for(j=i+1;j<10000;j++)
     {
       if(a[i]>a[j])
       {
         int temp=a[i];
         a[i]=a[j];
         a[j]=temp;
       }
     }
   }
   end=clock();
   double extime=(double) (end-start)/CLOCKS_PER_SEC;
   printf("\n\tExecution time for the bubble sort is %f seconds\n ",extime);

   for(i=0;i<10000;i++)
   {
     a[i]=rand()%10000;
   }
   clock_t start1,end1;
   start1=clock();
   // The Selection Sort
   for(i=0;i<10000;i++)
   {
     min=i;
     for(j=i+1;j<10000;j++)
     {
       if(a[min]>a[j])
       {
         min=j;
       }
     }
     temp=a[min];
     a[min]=a[i];
     a[i]=temp;
   }
   end1=clock();
   double extime1=(double) (end1-start1)/CLOCKS_PER_SEC;
   printf("\n");
   printf("\tExecution time for the selection sort is %f seconds\n\n", extime1);
   if(extime1<extime)
     printf("\tSelection sort is faster than Bubble sort by %f seconds\n\n", extime - extime1);
   else if(extime1>extime)
     printf("\tBubble sort is faster than Selection sort by %f seconds\n\n", extime1 - extime);
   else
     printf("\tBoth algorithms have the same execution time\n\n");
}