Creo que estás comparando manzanas y naranjas. la referencia de Mitos de rendimiento analiza la ventaja de un JIT para el acceso de campo, mientras que la segunda referencia discute la ventaja de un JIT para el acceso a métodos.
lo que tengo entendido, una analogía para acceder campo directo contra el acceso local (no locales campo acceso que usted escribió en su mensaje - no hay tal cosa como un campo local) es la siguiente:
class foo {
int bar = 42;
int doStuff(){
int x = 1;
x += bar;
x += bar;
x += bar;
return x;
}
}
Cada referencia a bar tiene un costo de rendimiento asociado. Un buen compilador reconocerá la oportunidad para la optimización y 'reescritura' el código como tal:
int doStuff(){
int x = 1f;
int local_bar = bar;
x += local_bar;
x += local_bar;
x += local_bar;
return x;
}
Sin JIT, esta es una optimización de la mano, que se consigue un 20% bache en el rendimiento.
Con un JIT, la optimización es innecesaria, ya que el JIT elimina el golpe de rendimiento del acceso al bar en primer lugar.
La segunda referencia describe el siguiente escenario:
class foo {
int bar = 42;
int getBar() { return bar; }
int doStuff(){
int x = 1;
x += getBar();
x += getBar();
x += getBar();
return x;
}
}
Cada llamada de función tiene una penalización de rendimiento asociado. Un compilador puede no almacenar en memoria caché las múltiples llamadas al método getBar() (como almacenó en caché los múltiples accesos de campo directos a bar en el ejemplo anterior), porque getBar() puede devolver un número completamente diferente cada vez que se llama (es decir, si componente aleatorio o basado en tiempo a su valor de retorno). Por lo tanto, es debe ejecutar tres llamadas al método.
Es vital entender que la función anterior se ejecutará aproximadamente a la misma velocidad con o sin un JIT.
Si reemplazara manualmente getBar() en la función anterior simplemente con bar, obtendría un aumento de rendimiento.En una máquina sin JIT, ese aumento de rendimiento es aproximadamente 3x, porque el acceso al campo es aún algo lento, por lo que reemplazar los métodos muy lentos con accesos de campo algo lentos solo produce un impulso moderado. Sin embargo, con un JIT, el acceso al campo es rápido, por lo que reemplazar los métodos muy lentos con acceso de campo rápido produce un impulso mucho mayor (7x).
¡Espero que tenga sentido!
Yo diría que sí, la documentación es incorrecta/inexacta/en base a mediciones muy diferentes. OMI, si se toma literalmente, realmente establece que el JAT acelera el acceso al campo en un 20% y un 133% (3x frente a 7x) al mismo tiempo, lo que es imposible – zapl
Exactamente, ese es mi punto. Me pregunto qué valores son correctos. – pawelzieba
Ambas declaraciones se basan en diferentes puntos de referencia [FieldAccessBenchmark.java] (http://code.google.com/p/dalvik/source/browse/trunk/benchmarks/FieldAccessBenchmark.java) para el 20% y [MethodInvocationBenchmark.java] (http://code.google.com/p/dalvik/source/browse/trunk/benchmarks/MethodInvocationBenchmark.java) para 133%. Podría ser una razón Pero no me importaría demasiado, solo <5% ([
zapl