¿Cómo puedo encontrar el tiempo de ejecución de una sección de mi programa en C?

StackOverflow https://stackoverflow.com/questions/173409

  •  05-07-2019
  •  | 
  •  

Pregunta

Estoy tratando de encontrar una manera de obtener el tiempo de ejecución de una sección de código en C. Ya probé time () y clock () de time.h, pero parece que time () devuelve Los segundos y el reloj () parecen darme milisegundos (¿o centisegundos?). Sin embargo, me gustaría algo más preciso. ¿Hay alguna manera de aprovechar el tiempo con una precisión de al menos microsegundos?

Esto solo necesita poder compilar en Linux.

¿Fue útil?

Solución

Se refirió a clock () y time () . ¿Estaba buscando gettimeofday () ? Eso completará una struct timeval , que contiene segundos y microsegundos.

Por supuesto, la resolución real depende del hardware.

Otros consejos

Para lo que vale, aquí hay una que es sólo unas pocas macros: 

#include <time.h>
clock_t startm, stopm;
#define START if ( (startm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define STOP if ( (stopm = clock()) == -1) {printf("Error calling clock");exit(1);}
#define PRINTTIME printf( "%6.3f seconds used by the processor.", ((double)stopm-startm)/CLOCKS_PER_SEC);

Entonces solo úsalo con: 

main() {
  START;
  // Do stuff you want to time
  STOP;
  PRINTTIME;
}

De http://ctips.pbwiki.com/Timer

Desea una aplicación profiler .

Palabras clave de búsqueda en SO y motores de búsqueda: perfiles de Linux

Pruebe " bench.h " ; te permite poner un START_TIMER; y STOP_TIMER (" nombre "); en su código, lo que le permite hacer una prueba de referencia arbitraria de cualquier sección del código (nota: solo se recomienda para secciones cortas, no para cosas que tomen docenas de milisegundos o más). Es preciso para el ciclo del reloj, aunque en algunos casos raros puede cambiar la forma en que se compila el código intermedio, en cuyo caso es mejor utilizar un generador de perfiles (aunque los perfiladores generalmente requieren más esfuerzo para usar secciones específicas del código).

Solo funciona en x86.

Es posible que desee buscar en Google una herramienta de instrumentación .

No encontrará una llamada a la biblioteca que le permita superar la resolución de reloj de su plataforma. Utilice un perfilador (man gprof) como sugirió otro póster, o - quick & amp; sucio: coloque un bucle alrededor de la sección de código ofensiva para ejecutarlo muchas veces, y use clock ().

gettimeofday () le proporciona una resolución de microsegundos, mientras que < El código> clock_gettime () le proporciona una resolución de nanosegundos. 

int clock_gettime(clockid_t clk_id, struct timespec *tp);

El clk_id identifica el reloj que se utilizará. Utilice CLOCK_REALTIME si desea que un reloj de todo el sistema sea visible para todos los procesos. Use CLOCK_PROCESS_CPUTIME_ID para el temporizador por proceso y CLOCK_THREAD_CPUTIME_ID para un temporizador específico de hilo.

Depende de las condiciones. Los perfiladores son agradables para las vistas globales en general. Sin embargo, si realmente necesita una vista precisa, mi recomendación es KISS. Simplemente ejecute el código en un bucle que demore aproximadamente un minuto. Luego, calcule un promedio simple basado en el tiempo total de ejecución y las iteraciones ejecutadas.

Este enfoque le permite:

  1. Obtenga resultados precisos con temporizadores de baja resolución.

  2. No se encuentra con problemas en los que la instrumentación interfiera con cachés de alta velocidad (l2, l1, branch..etc) cerca del procesador. Sin embargo, ejecutar el mismo código en un circuito cerrado también puede proporcionar resultados optimistas que pueden no reflejar las condiciones del mundo real.

No sé en qué entorno / sistema operativo está trabajando, pero su tiempo puede ser inexacto si otro hilo, tarea o proceso se anticipa a su código cronometrado en el medio. Sugiero explorar mecanismos tales como mutexes o semáforos para evitar que otros subprocesos prevean su proceso.

Si está desarrollando en x86 o x64, por qué no usa el contador de marca de tiempo: RDTSC .

Será más confiable que las funciones de Ansi C como time () o clock (), ya que RDTSC es una función atómica. El uso de las funciones de C para este propósito puede presentar problemas, ya que no tiene garantía de que el subproceso en el que se ejecutan no se desconecte y, como resultado, el valor que retornan no será una descripción precisa del tiempo de ejecución real que está tratando de medir. .

Con RDTSC puedes medir esto mejor. Deberá convertir la cuenta de ticks de nuevo en un formato H: M: S legible por humanos, que dependerá de la frecuencia del reloj de los procesadores, pero buscará en Google y estoy seguro de que encontrará ejemplos.

Sin embargo, incluso con RDTSC incluirá la hora de desactivación de su código, mientras que es una mejor solución que usar time () / clock () si necesita una medición exacta, tendrá que recurrir a un generador de perfiles que Instale su código y tenga en cuenta cuando su código no se está ejecutando realmente debido a cambios de contexto o lo que sea.

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top