nanoseconds - ¿Por qué debo usar t1-t0<0, no t1<t0, cuando uso System.nanoTime() en JAVA?

system get nanotime java

Question

Cuando estaba leyendo System.nanoTime () API en JAVA. Encontré esta línea:

se debe usar t1 - t0 <0, no t1 <t0, debido a la posibilidad de un desbordamiento numérico.

http://docs.oracle.com/javase/7/docs/api/java/lang/System.html#nanoTime()

Para comparar dos valores de nano tiempo

long t0 = System.nanoTime();
...
long t1 = System.nanoTime();

se debe usar t1 - t0 <0, no t1 <t0, debido a la posibilidad de un desbordamiento numérico.

Quiero saber por qué t1 - t0 < 0 es la mejor manera de evitar el desbordamiento.

Porque leí en otro hilo que A < B es más preferible que A - B < 0 .

Java Integer compareTo (): ¿por qué usar la comparación frente a la resta?

Estas dos cosas hacen la contradicción.

Answer 1

El tiempo de Nano no es un tiempo "real", es solo un contador que se incrementa a partir de un número no especificado cuando ocurre algún evento no especificado (tal vez la computadora se haya iniciado).

Se desbordará y se volverá negativo en algún momento. Si su t0 está justo antes de que se desborde (es decir, un positivo muy grande), y su t1 está justo después (un número negativo muy grande), entonces t1 < t0 (es decir, sus condiciones son incorrectas porque t1 ocurrió después de t0 ) .....

Pero, si dices t1 - t0 < 0 , bueno, la magia es que, por las mismas razones de desbordamiento (subdesbordamiento) (muy grandes restas negativas, un flujo positivo muy grande subdesbordará), el resultado será el número de nanosegundos que t1 fue después de t0 ..... y estaremos en lo cierto.

En este caso, dos errores realmente hacen un bien!

Answer 2

La cita de la API es en realidad:

Las diferencias en llamadas sucesivas que abarcan más de aproximadamente 292 años (2 ^ 63 nanosegundos) no calcularán con precisión el tiempo transcurrido debido a un desbordamiento numérico.

Si t0 y t1 se miden con 292 años de diferencia, experimentará un desbordamiento numérico. De lo contrario, la comparación o la resta funcionarán bien.

Answer 3

Utiliza cualquier método.
No habrá diferencia en los 290 años más próximos.
Tu programa (e incluso Java) no durará tanto.

Answer 4

t0 - t1 < 0 es mejor que t0 < t1 cuando estamos seguros de que la diferencia real de los valores (antes del desbordamiento) no es mayor que la mitad o el tamaño del conjunto que contiene todos los valores posibles.
Para nanosegundos, será de aproximadamente 292 años (los nanosegundos se almacenan en largos y la mitad del tamaño long es 2^64/2 = 2^63 nanosegundos ~ = 292 años).

Por lo tanto, para muestras de tiempo separadas con menos de 292 años, debemos usar t0 - t1 < 0 para obtener resultados correctos.

Para visualizarlo mejor, digamos que el ciclo contiene 8 valores posibles que son -4, -3, -2, -1 ,0, 1, 2, 3 .

Así que la línea de tiempo puede verse como

real time values:  .., -6, -5, -4, -3, -2, -1,  0,  1,  2,  3,  4,  5,  6,  7, ..
overflowed values: ..,  2,  3, -4, -3, -2, -1,  0,  1,  2,  3, -4, -3, -2, -1, ..

Veamos cómo se comportará t0 - t1 < 0 y t0 < t1 para los valores donde la diferencia será y no será mayor que 4 (la mitad del tamaño del ciclo y -4 es el valor mínimo, lo que significa que puede ser un resultado mínimo para calcular el delta). ). Tenga en cuenta que solo t0 - t1 < 0 dará resultados correctos cuando se desborda t1

1. delta = 1 con desbordamiento de mayor valor ( aviso : no hacemos desbordamiento de valor menor porque significaría que ambos valores están en el mismo ciclo, por lo que los cálculos serían los mismos como si no hubiera ningún desbordamiento)

   • Valores reales: t0 = 3 t1 = 4
   • desbordado: t0 = 3 t1 = -4
   • t0 < t1 ==> 3 < -4 -> falso
   • t0 - t1 < 0 ==> 3 - (-4) < 0 ==> -1 < 0 (7 desbordamientos a -1) verdadero

   así que solo para t0 - t1 < 0 obtuvimos el resultado correcto a pesar o quizás gracias al desbordamiento.

2. delta = 1 pero esta vez sin desbordamiento

   a) valores positivos

   • t0 = 2 , t1 = 3
   • 2 < 3 verdad
   • 2 - 3 < 0 ==> -1 < 0 verdadero

   b) valores negativos

   • t0 = -4 , t1 = -3
   • -4 < -3 verdadero
   • -4 - (-3) < 0 ==> -1 < 0 verdadero

   para el resto de casos donde real delta = 1 también obtendremos resultados correctos para las pruebas t0 < t1 y t0 - t1 < 0 ( t0 - t1 siempre será -1 )

3. delta = 3 (casi la mitad del ciclo)

   a1) con desbordamiento de mayor valor

   • Valores reales: t0 = 3 t1 = 6
   • desbordado: t0 = 3 t1 = -2
   • t0 < t1 ==> 3 < -2 -> falso
   • t0 - t1 < 0 ==> 3 - (-2) < 0 ==> -3 < 0 (5 desbordamientos a -3) verdadero

   a2) otro caso con rebosadero

   • Valores reales: t0 = 2 t1 = 5
   • desbordado: t0 = 2 t1 = -3
   • t0 < t1 ==> 2 < -3 -> falso
   • t0 - t1 < 0 ==> 2 - (-3) < 0 ==> -3 < 0 (de nuevo 5 se desborda a -3) verdadero

   
   Así que de nuevo solo t0 - t1 < 0 dio el resultado correcto.

   b) sin desbordamiento t0 - t1 siempre será igual a -3 (-delta), por lo que siempre dará el resultado correcto. t0 < t1 también dará una nueva resolución correcta

   • Valores reales: t0 = -1 t1 = 2
   • t0 < t1 ==> -1 < 2 -> verdadero
   • t0 - t1 < 0 ==> -1 - 2 < 0 ==> -3 < 0 verdadero

4. delta = 4 resultado de t0 - t1 siempre será igual a -4 por lo que también será <0 .

   ejemplos con desbordamiento
   a1)

   • Valores reales: t0 = 0 t1 = 4
   • desbordado: t0 = 0 t1 = -4
   • t0 < t1 ==> 0 < -4 -> falso
   • t0 - t1 < 0 ==> 0 - (-4) < 0 ==> -4 < 0 (4 desbordamientos a -4) verdadero

   a2)

   • Valores reales: t0 = 1 t1 = 5
   • desbordado: t0 = 1 t1 = -3
   • t0 < t1 ==> 1 < -4 -> falso
   • t0 - t1 < 0 ==> 1 - (-3) < 0 ==> -4 < 0 (4 desbordamientos a -4) verdadero

   Así que de nuevo solo t0 - t1 < 0 dan resultados correctos.

   Los ejemplos sin desbordamiento obviamente serán correctos para ambas pruebas.

5. delta = 5 (y más)

   a1) con desbordamiento
   (El valor mínimo para t0 es -1, así que comencemos con él)

   • Valores reales: t0 = -1 t1 = 4
   • desbordado: t0 = -1 t1 = -4
   • t0 < t1 ==> -1 < -4 -> falso
   • t0 - t1 < 0 ==> -1 - (-4) < 0 ==> 3 < 0 falso

   a2) con desbordamiento

   • Valores reales: t0 = 1 t1 = 6
   • desbordado: t0 = 1 t1 = -2
   • t0 < t1 ==> 1 < -2 -> falso
   • t0 - t1 < 0 ==> 1 - (-2) < 0 ==> 3 < 0 falso ambas pruebas fallaron

   b1) sin desbordamiento

   • t0 = -4 , t1 = 1
   • -4 < 1 verdadero
   • -4 - 1 < 0 ==> 3 < 0 (-5 se desborda a 3) falso

+-------------+-----------------------------+----------------------------+
|  tests if   | delta <= size of half cycle | delta > size of half cycle |
| t0 is less  |-----------------------------|----------------------------|
|  than t1    |  overflow  |  no overflow   | overflow  |  no overflow   |
|-------------|------------|----------------|-----------|----------------|
|   t0 < t1   |      -     |       +        |     -     |       +        |
|-------------|------------|----------------|-----------|----------------|
| t0 - t1 < 0 |      +     |       +        |     -     |       +        |
|-------------|------------|----------------|-----------|----------------|
| t0 - t1 > 0 |      -     |       -        |     +     |       -        |
+-------------+------------+----------------+-----------+----------------+