C - tiempo de cálculo de medición

Question

¿Hay alguna manera simple de cómo medir el tiempo de cálculo en C? Intenté utilizar el tiempo cuando lo ejecuté, pero necesito medir parte específica de un programa.

Gracias

Answer 1

Puede utilizar la función clock en <time.h> junto con la macro CLOCKS_PER_SEC:

clock_t start = clock() ; 
do_some_work() ; 
clock_t end = clock() ; 
double elapsed_time = (end-start)/(double)CLOCKS_PER_SEC ; 

Ahora elapsed_time mantiene el tiempo que se tardó en llamar do_some_work, en fracciones de segundo.

Answer 2

Puede probar el generador de perfiles "gprof". Más información aquí: http://www.cs.utah.edu/dept/old/texinfo/as/gprof.html

Answer 3

@codebolt - ¡Gracias! muy agradable. En Mac OS X, agregué un include de time.h, y pegué en tus cuatro líneas. Luego imprimí los valores de inicio, fin (enteros) y tiempo transcurrido. 1mS de resolución.

output: 
3 X: strcpy .name, .numDocks: start 0x5dc end 0x5e1 elapsed: 0.000005 
calloc: start 0x622 end 0x630 elapsed: 0.000014 

en mi programa foo.c tengo

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

pero funciona sin incluir explícitamente time.h. Uno de los otros hay que llevarlo en

código real:.

clock_t start = clock() ; 

strcpy(yard2.name, temp); /* temp is only persistant in main... */ 
strcpy(yard1.name, "Yard 1"); 
strcpy(yard3.name, "3 y 3 a 3 r 3 d 3"); 
yard1.numDocks = MAX_DOCKS; /* or so I guess.. */ 
yard2.numDocks = MAX_DOCKS; /* or so I guess.. */ 
yard3.numDocks = MAX_DOCKS; /* or so I guess.. */ 

clock_t end = clock() ; 
double elapsed_time = (end-start)/(double)CLOCKS_PER_SEC ; 
printf("3 X: strcpy .name, .numDocks: start 0x%x end 0x%x elapsed: %-12:8f \n", start, end, elapsed_time); 


start = clock() ; 
arrayD = calloc(yard2.numDocks, sizeof(struct dock)); /* get some memory, init it to 0 */ 
end = clock() ; 

elapsed_time = (end-start)/(double)CLOCKS_PER_SEC ; 
printf("calloc: start 0x%x end 0x%x elapsed: %-12:8f \n", start, end, elapsed_time); 

Answer 4

general, usted puede utilizar la función de clock() para obtener los tiempos de inicio y fin de una sola llamada a la función que se está probando. Si, sin embargo, do_some_work() es particularmente rápido, tiene que ser puesto en un bucle y tener el costo del bucle en sí un factor fuera, algo así como:

#define COUNT 10000 

// Get cost of naked loop. 

clock_t start_base = clock(); 
for (int i = count; i > 0; i--) 
    ; 
clock_t end_base = clock(); 

// Get cost of loop plus work. 

clock_t start = clock(); 
for (int i = count; i > 0; i--) 
    do_some_work() ; 
clock_t end = clock(); 

// Calculate cost of single call. 

double elapsed_time = end - start - (end_base - start_base); 
elapsed_time = elapsed_time/CLOCKS_PER_SEC/COUNT; 

Esto tiene al menos dos ventajas:

• obtendrá un tiempo promedio que es más representativo del tiempo real que debería tomar; y
• obtendrás una respuesta más precisa en el caso en que la función clock() tenga una resolución limitada.