Desarmar código de bytes nativo compilado Java JIT
compiler-construction jvm (5)
Consulte el analizador de rendimiento de Oracle Solaris Studio . Vi a Charlie Hunt demo en una conferencia, y fue simplemente impresionante. Le permite realizar la depuración y desensamblaje en tiempo de ejecución de las aplicaciones Java, es decir, ver las instrucciones de la máquina con zonas activas realzadas. Ver también este extracto del libro: http://charliehunt.ulitzer.com/node/2067673
Más documentación: Oracle Solaris Studio 12.2: Performance Analyzer
¿Hay alguna forma de hacer un volcado de ensamblaje del código nativo generado por el compilador Java-in-time?
Y una pregunta relacionada: ¿hay alguna forma de utilizar el compilador JIT sin ejecutar la JVM para compilar mi código en el código máquina nativo?
No puedes usar el JIT para producir un ejecutable independiente, necesitarías otro sistema como GCJ . En cuanto a ver el código generado JIT, consulte la fuente OpenJDK para buscar opciones de depuración. Puede construir su propia copia con los habilitados y ver qué está haciendo el JIT, o agregar sus propias mejoras para generar lo que desee.
Sí, hay una forma de imprimir el código nativo generado (requiere OpenJDK 7).
No, no hay forma de compilar el bytecode de Java con el código nativo utilizando el JIT JDK y guardarlo como un ejecutable nativo.
Incluso si esto fuera posible, probablemente no sería tan útil como crees. La JVM realiza algunas optimizaciones muy sofisticadas, e incluso puede optimizar el código sobre la marcha si es necesario. En otras palabras, no es tan simple como el JIT compila su código para el lenguaje de máquina nativo, y luego ese lenguaje de máquina nativa se mantendrá sin cambios mientras el programa se está ejecutando. Además, esto no le permitiría crear un archivo ejecutable nativo que sea independiente de la JVM y la biblioteca de tiempo de ejecución.
Sí, también estaba pensando que sería difícil obtener salida nativa de JIT, pero este tipo de gente sigue mostrando código nativo, pero no dice cómo obtuvo la salida. Puedo entender si la salida del compilador JIT sería inconsistente ya que cambiará de vez en cuando o se purgará de la memoria caché del código solo para ser regenerada más adelante, pero ¿cómo se obtiene una instantánea rápida de algún ensamblaje para algunos bloques de código? : |
Si Amigable Clark Kant pensó que tu pregunta era una herejía, realmente se desharía de esta respuesta. Archive esto en "lo que es posible" no necesariamente en "Justin recomienda". :-)
Una opción es usar IKVM.NET para procesar su código Java usando Mono . IKVM.NET le permite ejecutar código Java sobre .NET o Mono CLR . Algunos podrían decir que está omitiendo la JVM de esta manera, aunque sería más exacto decir que IKVM.NET es realmente una implementación de la JVM que se ejecuta en la CLR.
En cualquier caso, si hace esto, ahora tiene la opción de hacer una compilación de Ahead-of-time (AOT) de su código con Mono. Es decir, puede compilar su código hasta la versión nativa de la máquina, lo que significa que no necesita el CLR o la JVM en tiempo de ejecución.
A diferencia de lo que dice Jesper anteriormente, el uso de la compilación AOT puede dar como resultado un mejor rendimiento. Si bien es cierto que la JVM (y la CLR) realizan algunas optimizaciones en el tiempo de ejecución que no son posibles en tiempo de compilación, lo contrario también es cierto. Además, una de las opciones es usar LLVM para la generación de código, lo que generalmente resulta en un mejor rendimiento.
Aquí está la tubería en pocas palabras:
Su código -> IKVM.NET -> Mono -> LLVM -> Ejecutable nativo
O bien, utilice un compilador Java diseñado para que AOT genere ejecutables nativos desde el principio (como GCJ o Excelsior Jet ).
Un lugar donde la opción Mono / IKVM.NET podría ser útil es si desea usar una biblioteca Java como parte de una aplicación de iPhone (usando MonoTouch ). App Store solo permite binarios nativos.
EDITAR: También puede usar LLVM VMKit para compilar AOT código de Java a código máquina. Este es conceptualmente el mismo proceso que describí con Mono, pero manteniendo esas desagradables cosas CIL fuera de la imagen.