Mientras miraba una pregunta de micro-optimización que hice ayer (here), encontré algo extraño: una declaración or en Java está ejecutando ligeramente más rápido que buscar un valor booleano en una matriz de booleanos.¿Por qué este código con varias instrucciones "o" es más rápido que usar una tabla de búsqueda en Java?
En mis pruebas, ejecutando los siguientes algoritmos en long valores de 0 a 1 mil millones, alg1 es aproximadamente un 2% más rápido. (He alterado el orden en que se prueban los algoritmos, y obtengo los mismos resultados). Mi pregunta es: ¿Por qué es alg1 más rápido? Hubiera esperado que alg2 fuera ligeramente más rápido ya que usa una tabla de búsqueda, mientras que alg1 tiene que ejecutar 4 comparaciones y 3 o operaciones para el 75% de las entradas.
private final static boolean alg1(long n)
{
int h = (int)(n & 0xF);
if(h == 0 || h == 1 || h == 4 || h == 9)
{
long tst = (long)Math.sqrt(n);
return tst*tst == n;
}
return false;
}
private final static boolean[] lookup = new boolean[16];
static
{
lookup[0] = lookup[1] = lookup[4] = lookup[9] = true;
}
private final static boolean alg2(long n)
{
if(lookup[(int)(n & 0xF)])
{
long tst = (long)Math.sqrt(n);
return tst*tst == n;
}
else
return false;
}
Si tienes curiosidad, este código está probando si un número es un cuadrado perfecto, y utiliza el hecho de que los cuadrados perfectos deben terminar en 0, 1, 4, 9 o en hexadecimal.
Una búsqueda simple en el nivel del procesador es generalmente bastante más rápida que incluso una pequeña serie de cálculos. Pensando g es la verificación de límites/otra sobrecarga que Java agrega para administrar el proceso. –
límites comprobando FTL! –