que - Tiempo de ejecución del programa C

lenguaje c ejemplos

Question

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

No estoy seguro de cómo se Clocks_per_second valor Clocks_per_second ?

En Java, tomo la hora 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 generador de perfiles sería una opción, pero estoy buscando implementar un temporizador yo mismo.

Gracias

Answer 1

(Todas las respuestas aquí faltan, si su administrador de sistema cambia el tiempo del sistema, o su zona horaria tiene diferentes tiempos de invierno y sommer. Por lo tanto ...)

En uso de Linux: clock_gettime(CLOCK_MONOTONIC_RAW, &time_variable); No se ve afectado si el administrador del sistema cambia la hora o si vive en un país con horario de invierno diferente al 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 states:

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.

Answer 2

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

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

Answer 3

Cada solución no funciona en mi sistema.

Puedo usar

#include <time.h>
double difftime(time_t time1, time_t time0);

Answer 4

Comparación del tiempo de ejecución de sort de burbuja y selección de ordenación Tengo un programa que compara el tiempo de ejecución de ordenación de burbuja y clasificación de selección. Para saber el tiempo de ejecución de un bloque de código, calcule el tiempo antes y después del bloque

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

Answer 5

Debe tener en cuenta que medir el tiempo que llevó ejecutar un programa depende en gran medida de la carga que tenga la máquina en ese momento específico.

Sabiendo eso, la forma de obtener la hora 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!

Answer 6

En simple vainilla 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;
}

Answer 7

La mayoría de los programas simples tienen tiempo de cálculo en milisegundos. Entonces, supongo, encontrarás esto ú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 time como este time ./a.out

Answer 8

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.

Answer 9

Muchas respuestas han sugerido clock() y luego CLOCKS_PER_SEC desde time.h Esta es probablemente una mala idea, porque esto es lo que mi archivo /bits/time.h dice:

/* 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

Así que CLOCKS_PER_SEC podría definirse como 1000000, dependiendo de qué opciones use para compilar, y por lo tanto no parece una buena solución.

Answer 10

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

obra

$ time ./a.out

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

Answer 11

Usted funcionalmente quiere 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 se mide en microsegundos, no solo en segundos.

Answer 12

CLOCKS_PER_SEC es 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, mides 4,52 segundos). La precisión depende de la arquitectura; en los sistemas modernos, obtienes fácilmente 10 ms o menos, pero en las máquinas Windows más antiguas (de la era Win98) estaba más cerca de los 60 ms.

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

El System.currentTimeMillis() Java no mide lo mismo. Es un "reloj de pared": puede ayudarte a medir cuánto tiempo le tomó al programa ejecutarlo, pero no te dice cuánto tiempo de CPU se usó. En sistemas multitareas (es decir, todos ellos), estos pueden ser muy diferentes.

Answer 13

 #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á como el encanto.