Microsegundo tiempo de proceso exacto (o mejor) en Linux

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

Pregunta

Necesito una forma muy precisa de cronometrar partes de mi programa. Podría usar el reloj normal de alta resolución para esto, pero eso devolverá el tiempo de Wallclock, que no es lo que necesito: necesito el tiempo dedicado a ejecutar solo mi proceso.

Recuerdo claramente haber visto un parche del kernel de Linux que me permitiría cronometrar mis procesos con una precisión de nanosegundos, excepto que olvidé marcarlo y también olvidé el nombre del parche :(.

Aunque recuerdo cómo funciona:

En cada cambio de contexto, leerá el valor de un reloj de alta resolución y agregará el delta de los dos últimos valores al tiempo de proceso del proceso en ejecución. Esto produce una vista precisa de alta resolución del tiempo de proceso real del proceso.

El tiempo de proceso regular se mantiene usando el reloj regular, que creo que es preciso en milisegundos (1000Hz), que es demasiado grande para mis propósitos.

¿Alguien sabe de qué parche de kernel estoy hablando? También recuerdo que era como una palabra con una letra antes o después, algo como 'rtimer' o algo así, pero no recuerdo exactamente.

(Otras sugerencias son bienvenidas también)

El Programador Completamente Justo sugerido por Marko no es lo que estaba buscando, pero parece prometedor. El problema que tengo con esto es que las llamadas que puedo usar para obtener el tiempo de proceso aún no devuelven valores suficientemente granulares.

  • times () está devolviendo los valores 21, 22, en milisegundos.
  • clock () está devolviendo valores 21000, 22000, la misma granularidad.
  • getrusage () está devolviendo valores como 210002, 22001 (y algunos), parecen tener un poco más de precisión, pero los valores parecen visiblemente iguales.

Entonces, ahora el problema que probablemente esté teniendo es que el kernel tiene la información que necesito, simplemente no sé la llamada al sistema que la devolverá.

¿Fue útil?

Solución

Si está buscando este nivel de resolución de tiempo, es probable que esté intentando realizar una microoptimización. Si ese es el caso, debe consultar PAPI . No solo proporciona información de tiempo de reloj de pared y virtual (solo proceso), sino que también brinda acceso a los contadores de eventos de la CPU, lo que puede ser indispensable cuando se intenta mejorar el rendimiento.

http://icl.cs.utk.edu/papi/

Otros consejos

Consulte esta pregunta para obtener más información. .

Algo que he usado para tales cosas es gettimeofday (). Proporciona una estructura con segundos y microsegundos. Llámalo antes del código, y nuevamente después. Luego simplemente reste las dos estructuras usando timersub, y puede obtener el tiempo que tomó en segundos desde el campo tv_usec.

Si necesita unidades de tiempo muy pequeñas para (supongo) probar la velocidad de su software, recomendaría simplemente ejecutar las partes que desea medir en un bucle millones de veces, tómese el tiempo antes y después del bucle y calcular el promedio. Un efecto secundario agradable de hacer esto (además de no tener que averiguar cómo usar los nanosegundos) es que obtendría resultados más consistentes porque la sobrecarga aleatoria causada por el escuadrón de os será promediada.

Por supuesto, a menos que su programa no necesite ser ejecutado millones de veces en un segundo, probablemente sea lo suficientemente rápido si no puede medir el tiempo de ejecución en milisegundos.

Creo que CFC ( Scheduler completamente justo ) es lo que estás buscando.

Puede usar el Temporizador de eventos de alta precisión ( HPET ) si tiene un documento bastante reciente. 2.6 kernel. Consulte Documentation / hpet.txt sobre cómo utilizarlo. Sin embargo, esta solución depende de la plataforma y creo que solo está disponible en los sistemas x86 más nuevos. HPET tiene al menos un temporizador de 10MHz, por lo que debe adaptarse a sus requisitos fácilmente.

Creo que varias implementaciones de PowerPC de Freescale también admiten un contador de instrucciones de ciclo exacto. Utilicé esto hace varios años para perfilar código altamente optimizado, pero no puedo recordar cómo se llama. Creo que Freescale tiene un parche de kernel que debe aplicar para acceder desde el espacio de usuario.

http://allmybrain.com/2008/ 06/10 / timing-cc-code-on-linux /

podría ser de ayuda para usted (directamente si lo está haciendo en C / C ++, pero espero que le sirva de ayuda, incluso si no lo está) ... Afirma que proporciona una precisión de microsegundos, que simplemente pasa su criterio. :)

Creo que encontré el parche de kernel que estaba buscando. Lo publico aquí para que no olvide el enlace:

http://user.it.uu.se/~mikpe/ linux / perfctr / http://sourceforge.net/projects/perfctr/

Editar: funciona para mis propósitos, aunque no es muy fácil de usar.

No afiliado a StackOverflow
scroll top