Cómo calcular el tiempo de una operación en microsegundos de precisión

Question

Quiero calcular el rendimiento de una función en precisión de micro segundos en la plataforma de Windows.

Ahora Windows tiene una granulidad de milisegundos, así que ¿cómo puedo lograrlo?

Intenté seguir la muestra, pero no obteniendo los resultados correctos.

LARGE_INTEGER ticksPerSecond = {0}; 
LARGE_INTEGER tick_1 = {0}; 
LARGE_INTEGER tick_2 = {0}; 
double uSec = 1000000; 

// Get the frequency 
QueryPerformanceFrequency(&ticksPerSecond); 

//Calculate per uSec freq 
double uFreq = ticksPerSecond.QuadPart/uSec; 

// Get counter b4 start of op 
QueryPerformanceCounter(&tick_1); 

// The ope itself 
Sleep(10); 

// Get counter after opfinished 
QueryPerformanceCounter(&tick_2); 

// And now the op time in uSec 
double diff = (tick_2.QuadPart/uFreq) - (tick_1.QuadPart/uFreq); 

Answer 1

Ejecute la operación en un bucle un millón de veces más o menos y divida el resultado por ese número. De esa forma obtendrás el tiempo de ejecución promedio sobre tantas ejecuciones. Sincronizar una (o incluso cien) ejecuciones de una operación muy rápida es muy poco fiable, debido a la multitarea y otras cosas.

Answer 2

Si usted está haciendo esto para fuera de línea de perfiles, de una manera muy sencilla es ejecutar la función de 1000 veces, medir al milisegundo más cercano y se dividen por 1000.

Answer 3

• compilarlo
• vistazo a la ensamblador de salida
• contar el número de cada instrucción en su función
• aplican los ciclos por instrucción de su procesador objetivo
• terminan con un ciclo de recuento
• se multiplica por la velocidad de reloj está ejecutando en
• aplicar factores de escala arbitrarios para dar cuenta de los errores de caché y la rama erróneas predicciones lol

(hombre que soy por lo iba a conseguir abajo votado por esta respuesta)

Answer 4

No, probablemente obtenga un resultado preciso, QueryPerformanceCounter() funciona bien para temporizar intervalos cortos. Lo que está mal es su expectativa de la precisión de Sleep(). Tiene una resolución de 1 milisegundo, su precisión es mucho peor. No más de aproximadamente 15.625 milisegundos en la mayoría de las máquinas con Windows.

Para obtenerlo en cualquier lugar cercano a 1 milisegundo, primero tendrá que llamar al timeBeginPeriod(1). Eso probablemente mejorará el emparejamiento, ignorando la inestabilidad que obtendrá de Windows como sistema operativo multitarea.

Answer 5

Para obtener una resolución más fina de 1 ms, deberá consultar la documentación de su sistema operativo. Puede haber API para obtener una resolución de temporizador en resolución de microsegundos. Si es así, ejecute su aplicación muchas veces y tome los promedios.

Answer 6

O puede utilizar gettimeofday() que le da una estructura timeval que es una marca de tiempo (hasta mu s)

Answer 7

me gusta la respuesta de Matti Virkkunen. Verifique la hora, llame a la función una gran cantidad de veces, verifique la hora en que termina y divida por el número de veces que llamó a la función. Mencionó que podría estar apagado debido a las interrupciones del sistema operativo. Puede variar la cantidad de veces que realiza la llamada y ver la diferencia. ¿Puedes elevar la prioridad del proceso? ¿Puedes obtenerlo para todas las llamadas dentro de un único intervalo de tiempo del sistema operativo?

Dado que no sabe cuándo puede cambiar el sistema operativo, puede poner todo esto dentro de un bucle más grande para hacer toda la medición una gran cantidad de veces, y guardar el número más pequeño, ya que es el que tenía el menor número de interrupciones del sistema operativo. Todavía puede ser mayor que el tiempo real para que se ejecute la función, ya que aún puede contener algunas interrupciones del sistema operativo.

Answer 8

Sanjeet,

Parece (para mí) como que está haciendo esto exactamente correcto. QueryPerformanceCounter es una forma perfectamente buena de medir períodos cortos de tiempo con un alto grado de precisión. Si no está viendo el resultado que esperaba, es más probable porque el sueño no está durmiendo durante el tiempo que esperaba. Sin embargo, es probable que se mida correctamente.

Quiero volver a su pregunta original sobre cómo medir el tiempo en ventanas con precisión microsegunda. Como ya sabe, el contador de alto rendimiento (es decir, QueryPerformanceCounter) "marca" la frecuencia indicada por QueryPerformanceFrequency. Eso significa que se puede medir el tiempo con una precisión igual a:

1/frecuencia segundos

En mi máquina, QueryPerformanceFrequency informa 2.337.910 (cuentas/segundo). Eso significa que el QPC de mi computadora puede medir con precisión de 4.277e-7 segundos, o 0.427732 microsegundos. Eso significa que el menor tiempo que puedo medir es 0.427732 microsegundos. Esto, por supuesto, le da la precisión que originalmente pidió :) La frecuencia de su máquina debe ser similar, pero siempre puede hacer los cálculos y verificarlo.