Timer Resolution - Contador temporal de resolución. Java Game 6

El Timer Resolution o contador de resolución en un juego es el tiempo mínimo que tarda en sucederse una imagen en pantalla para que parezca continua en el ojo humano.
Por ejemplo, diff nos calula la diferencia de tiempo reciente en milisegundos tomando como referencia que t1 y t2 nos pueden medir la diferencia de tiempo en el que se realiza un bucle run() para un juego.

               long t1 = System.currentTimeMillis ();
               long t2 = System.currentTimeMillis ();
               long diff = t2 - t1; // en ms

currentTimeMillis() nos da el valor de resolución en milisegundos, que desafortunadamente depende del sistema operativo.
En Windows 95 y 98 la resolución es de 55 ms, lo que significa que las llamadas a currentTimeMillis() sólo devolverán valores diferentes aproximadamente cada 55 ms.
En el bucle de animación run(), el efecto general de una mala resolución hace que la animación se ejecute más lento de lo previsto y reduce el FPS. Esto se debe al valor timeDiff, que se establecerá en 0 si la actualización del juego y el tiempo de renderizado es inferior a 55 ms. Esto hace que el tiempo de reposo sea asignado al valor del período de iteración, haciendo que cada iteración duerma más de lo necesario.
Windows 2000, NT y XP, currentTimeMillis() tiene una resolución de 10 a 15 ms, lo que hace posible obtener de 67 a 100 FPS. Esto se considera aceptable para la mayoria de los juegos.
En Mac OS X y Linux hay resoluciones del temporizador de 1 ms, lo que es excelente.

Para calcular los FPS (frames por segundo) a partir de un currentTimeMillis() dado de 15ms, simplemente tenemos que pasar de 15ms a segundos, lo que serían 0,015segundos, que para un frame vendría dado por el cociente entre 1Frame/0,015 dándonos como resultado aproximado 67FPS, una medida más aproximada de lo que queremos conseguir para un juego.

Si lo que queremos es hacer el cálculo en nanosegundos simplemente tendríamos que hacer lo mismo:
              long count1 = System.nanoTime( ); 
              long count2 = System.nanoTime( ); 
              long diff = (count2 – count1); // in nanoseconds

Para la medición del Timer Resolution tenemos dos clases, una principal llamada TimerRes(), y otra secundaria llamada StopWatch():

public class TimerRes { public static void main(String args[]){ sysTimeResolution(); perfTimeResolution(); } private static void sysTimeResolution(){ long total, count1, count2; count1 = System.currentTimeMillis( ); count2 = System.currentTimeMillis( ); while(count1 == count2) count2 = System.currentTimeMillis( ); total = 1000L * (count2 - count1); count1 = System.currentTimeMillis( ); count2 = System.currentTimeMillis( ); while(count1 == count2) count2 = System.currentTimeMillis( ); total += 1000L * (count2 - count1); count1 = System.currentTimeMillis( ); count2 = System.currentTimeMillis( ); while(count1 == count2) count2 = System.currentTimeMillis( ); total += 1000L * (count2 - count1); count1 = System.currentTimeMillis( ); count2 = System.currentTimeMillis( ); while(count1 == count2) count2 = System.currentTimeMillis( ); total += 1000L * (count2 - count1); System.out.println("System Time resolution: " + total/4 + " microsecs"); } // end of sysTimeResolution( ) private static void perfTimeResolution(){ StopWatch sw = new StopWatch(); System.out.println("Perf Resolution: " + sw.getResolution( ) + " nsecs"); sw.start(); long time = sw.stop( ); System.out.println("Perf Time " + time + " nsecs"); } }

public class StopWatch { private Perf hiResTimer; private long freq; private long startTime; public StopWatch(){ hiResTimer = Perf.getPerf( ); freq = hiResTimer.highResFrequency( );//numero de cuentas por segundo } public void start( ){ startTime = hiResTimer.highResCounter( );//valor reciente del contador } public long stop( ){ // tiempo en nanosegundos return (hiResTimer.highResCounter( ) - startTime)*1000000000L/freq; } public long getResolution(){ //resolucion en nanosegundos long diff, count1, count2; count1 = hiResTimer.highResCounter( ); count2 = hiResTimer.highResCounter( ); while(count1 == count2) count2 = hiResTimer.highResCounter( ); diff = (count2 - count1); count1 = hiResTimer.highResCounter( ); count2 = hiResTimer.highResCounter( ); while(count1 == count2) count2 = hiResTimer.highResCounter( ); diff += (count2 - count1); count1 = hiResTimer.highResCounter( ); count2 = hiResTimer.highResCounter( ); while(count1 == count2) count2 = hiResTimer.highResCounter( ); diff += (count2 - count1); count1 = hiResTimer.highResCounter( ); count2 = hiResTimer.highResCounter( ); while(count1 == count2) count2 = hiResTimer.highResCounter( ); diff += (count2 - count1); return (diff*1000000000L)/(4*freq); } // end of getResolution( ) } // end of StopWatch class

Tendremos dos métodos sysTimeResolution() y perfTimeResolution(), el primero realiza el cálculo como hemos explicado anteriormente, y el segundo realiza el cálculo a través del método Perf, siempre un poco mas exacto. Los métodos start() y stop() añaden una pequeña sobrecarga al contador, como se ilustra en el método perfTimeResolution() en TimerRes.
El ciclo de animación en run() depende de un buen temporizador y de la precisión de la llamada a la función sleep().

Otra manera interesante de ver el tiempo que perdemos en la máquina virtual de java 'JVM' con el método currentTimeMillis() es a través de la siguiente clase en la que creamos una variable delay a la que le imponemos un retardo sleep() y calculamos su porcentaje de pérdida:

public class SleepPorcentaje{ private static DecimalFormat df; public static void main(String args[]){ df = new DecimalFormat("0.##"); // 2 dp //tiempo de retardos o sleep sleepTest(1000); sleepTest(500); sleepTest(200); sleepTest(100); sleepTest(50); sleepTest(20); sleepTest(10); sleepTest(5); sleepTest(1); } // end of main() private static void sleepTest(int delay){ long timeStart = System.nanoTime();//tiempo de comienzo en nanosegundos dado por JVM try { Thread.sleep(delay);//le damos un tiempo de descanso delay } catch(InterruptedException e) {} //tras el tiempo de descanso calculamos una nueva diferencia de tiempo timeDiff //pasamos el tiempo a milisegundos al dividir por 1000000 double timeDiff = ((double)(System.nanoTime() - timeStart))/(1000000L); //calculamos el porcentaje de error entre la medicio delay y la de timeDiff double porcent = delay/timeDiff*100; double err = ((delay - timeDiff)/timeDiff) * 100; System.out.println("Sleep: "+delay +" ms: "+df.format(timeDiff)+" ms err: "+df.format(err) +"%"); } // end of sleepTest( ) } // end of SleepAcc class

El resultado será:

run: Sleep: 1000 ms: 999,78 ms err: 0,02% Sleep: 500 ms: 499,93 ms err: 0,01% Sleep: 200 ms: 200,1 ms err: -0,05% Sleep: 100 ms: 99,69 ms err: 0,31% Sleep: 50 ms: 49,71 ms err: 0,58% Sleep: 20 ms: 19,65 ms err: 1,8% Sleep: 10 ms: 9,82 ms err: 1,81% Sleep: 5 ms: 5,3 ms err: -5,71% Sleep: 1 ms: 4,84 ms err: -79,35% BUILD SUCCESSFUL (total time: 2 seconds)

Ahora expondremos otro ejemplo del método run() para un juego:
en este próximo ejemplo se calcula el tiempo de ejecución de sleep () y su error (almacenado en overSleepTime). Thread.yield() se utiliza para dar a otros subprocesos una oportunidad de ejecutarse si la animación no ha dormido por un tiempo.
Aquí está el método run() actualizado:

private static final int NO_DELAYS_PER_YIELD = 16; /* Número de fotogramas con un retardo de 0 ms antes de que el hilo de la animación corra de nuevo. */ public void run( ){ /* Repeatedly update, render, sleep so loop takes close to period nsecs. Sleep inaccuracies are handled. The timing calculation use the Java 3D timer. */ long beforeTime, afterTime, timeDiff, sleepTime; long overSleepTime = 0L; int noDelays = 0; boolean running; beforeTime = System.nanoTime(); running = true; while(running) { gameUpdate(); gameRender(); paintScreen(); afterTime = System.nanoTime(); timeDiff = afterTime - beforeTime; sleepTime = (period - timeDiff) - overSleepTime; if (sleepTime > 0) { // some time left in this cycle try { Thread.sleep(sleepTime/1000000L); // nano -> ms } catch(InterruptedException ex){} overSleepTime = (System.nanoTime() - afterTime) - sleepTime; } else{ // sleepTime <= 0; frame took longer than the period overSleepTime = 0L; if (++noDelays >= NO_DELAYS_PER_YIELD) { Thread.yield( ); // give another thread a chance to run noDelays = 0; } } beforeTime = System.nanoTime(); } System.exit(0); } // end of run( )

Si la llamada a sleep() duerme durante 12 ms en vez de los 10 ms deseados, entonces a overSleepTime se le asignará 2 ms. En la siguiente iteración del bucle este valor se deducirá
del tiempo de reposo, reduciéndolo a 2 ms, de esta manera las inexactitudes de sleep se corrigen.
Si los pasos de actualización y reproducción del juego duran más que el período de iteración, entonces SleepTime tendrá un valor negativo y esta iteración no incluirá un sleep, esto hace que el contador noDelays se incremente, y cuando alcanza NO_DELAYS_PER_YIELD, yield() será llamado. Esto permite que otros subprocesos se ejecuten si es necesario, y evita el uso de un período de descanso arbitrario en run().
Los valores de tiempo cambian de milisegundos a nanoseconds, lo que motiva el cambio a variables largas. Además, el tiempo se debe convertir de nanoseconds a milisegundos antes de llamar a sleep(), o estaré esperando mucho tiempo para que el juego se reanude.