¿Qué hace un compilador just-in-time (JIT)?

¿Qué hace un compilador JIT específicamente en comparación con un compilador no JIT? ¿Alguien puede dar una descripción sucinta y fácil de entender?

Un compilador JIT se ejecuta después de que el programa ha comenzado y compila el código (generalmente código de bytes o algún tipo de instrucciones de VM) sobre la marcha (o justo a tiempo, como se llama) en una forma que generalmente es más rápida, generalmente la CPU nativa del host conjunto de instrucciones. Un JIT tiene acceso a información dinámica de tiempo de ejecución, mientras que un compilador estándar no tiene y puede hacer mejores optimizaciones, como funciones de línea que se usan con frecuencia.

Esto contrasta con un compilador tradicional que compila todo el código en lenguaje máquina antes de que el programa se ejecute por primera vez.

Parafraseando, los compiladores convencionales compilan todo el programa como un archivo EXE ANTES de la primera vez que lo ejecutas. Para los programas de estilo más nuevos, se genera un ensamblado con pseudocódigo (código p). Solo DESPUÉS de ejecutar el programa en el sistema operativo (por ejemplo, haciendo doble clic en su icono) el compilador (JIT) se activará y generará el código de máquina (código m) que el procesador basado en Intel o lo que sea que comprenda.

Al principio, un compilador era responsable de convertir un lenguaje de alto nivel (definido como un nivel superior al ensamblador) en código de objeto (instrucciones de máquina), que luego se vincularía (mediante un vinculador) en un ejecutable.

En un momento de la evolución de los lenguajes, los compiladores compilarían un lenguaje de alto nivel en pseudocódigo, que luego sería interpretado (por un intérprete) para ejecutar su programa. Esto eliminó el código objeto y los ejecutables, y permitió que estos lenguajes fueran portables a múltiples sistemas operativos y plataformas de hardware. Pascal (que compiló el código P) fue uno de los primeros; Java y C # son ejemplos más recientes. Finalmente, el término P-Code fue reemplazado por bytecode, ya que la mayoría de las pseudo-operaciones son de un byte largo.

Un compilador Just-In-Time (JIT) es una característica del intérprete en tiempo de ejecución, que en lugar de interpretar el código de bytes cada vez que se invoca un método, compilará el código de bytes en las instrucciones del código de máquina de la máquina en ejecución, y luego invocará esto código objeto en su lugar. Idealmente, la eficiencia de ejecutar código objeto superará la ineficiencia de recompilar el programa cada vez que se ejecuta.

JIT: justo a tiempo, la palabra misma dice cuándo es necesario (bajo demanda)

Escenario típico:

El código fuente se convierte completamente en código de máquina.

Escenario JIT:

El código fuente se convertirá en lenguaje ensamblador como estructura [para ex IL (lenguaje intermedio) para C #, ByteCode para java].

El código intermedio se convierte en lenguaje de máquina solo cuando la aplicación necesita que los códigos requeridos solo se conviertan en código de máquina.

Comparación JIT vs no JIT:

• En JIT, no todo el código se convierte en código de máquina primero, una parte del código que es necesario se convertirá en código de máquina y luego, si un método o funcionalidad llamada no está en la máquina, se convertirá en código de máquina ... se reduce carga en la CPU.

• Como el código de máquina se generará en tiempo de ejecución ... el compilador JIT producirá código de máquina que está optimizado para ejecutar la arquitectura de CPU de la máquina.

Ejemplos JIT:

1. En Java, JIT está en JVM (Java Virtual Machine)
2. En C # está en CLR (Common Language Runtime)
3. En Android está en DVM (Dalvik Virtual Machine), o ART (Android RunTime) en versiones más recientes.

Como otros han mencionado

JIT significa Just-in-Time, lo que significa que el código se compila cuando es necesario, no antes del tiempo de ejecución.

Solo para agregar un punto a la discusión anterior, JVM mantiene un recuento de cuántas veces se ejecuta una función. Si este recuento excede un límite predefinido, JIT compila el código en lenguaje máquina que puede ser ejecutado directamente por el procesador (a diferencia del caso normal en el que javac compila el código en bytecode y luego java - el intérprete interpreta este bytecode línea por línea lo convierte en código de máquina y se ejecuta).

Además, la próxima vez que se calcule esta función, se ejecutará nuevamente el mismo código compilado, a diferencia de la interpretación normal en la que el código se interpreta nuevamente línea por línea. Esto hace que la ejecución sea más rápida.

El compilador JIT solo compila el código de bytes a un código nativo equivalente en la primera ejecución. En cada ejecución sucesiva, la JVM simplemente usa el código nativo ya compilado para optimizar el rendimiento.

Sin el compilador JIT, el intérprete JVM traduce el código de byte línea por línea para que parezca que se está ejecutando una aplicación nativa.

Fuente

JIT significa Just-in-Time, lo que significa que el código se compila cuando es necesario, no antes del tiempo de ejecución.

Esto es beneficioso porque el compilador puede generar código optimizado para su máquina en particular. Un compilador estático, como su compilador C promedio, compilará todo el código en código ejecutable en la máquina del desarrollador. Por lo tanto, el compilador realizará optimizaciones basadas en algunos supuestos. Puede compilarse más lentamente y hacer más optimizaciones porque no ralentiza la ejecución del programa para el usuario.

Después de que el compilador de Java haya generado el código de bytes (que es neutral en cuanto a la arquitectura), la ejecución será manejada por la JVM (en Java). El cargador cargará el código de bytes en JVM y luego se interpretará cada instrucción de bytes.

Cuando necesitamos llamar a un método varias veces, necesitamos interpretar el mismo código muchas veces y esto puede llevar más tiempo del necesario. Entonces tenemos los compiladores JIT (justo a tiempo). Cuando el byte ha sido cargado en JVM (su tiempo de ejecución), todo el código se compilará en lugar de interpretarse, ahorrando así tiempo.

Los compiladores JIT solo funcionan durante el tiempo de ejecución, por lo que no tenemos ninguna salida binaria.

Just In Time Compiler (JIT):
compila los códigos de bytes de Java en instrucciones de máquina de esa CPU específica.

Por ejemplo, si tenemos una declaración de bucle en nuestro código de Java:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

El código de bucle anterior se ejecuta 10 veces si el valor de i es 0.

No es necesario compilar el código de bytes 10 veces una y otra vez, ya que la misma instrucción se ejecutará 10 veces. En ese caso, es necesario compilar ese código solo una vez y el valor se puede cambiar por la cantidad requerida de veces. Entonces, el compilador Just In Time (JIT) realiza un seguimiento de dichas declaraciones y métodos (como se dijo anteriormente) y compila dichos fragmentos de código de bytes en el código de la máquina para un mejor rendimiento.

Otro ejemplo similar es que una búsqueda de un patrón usando "Expresión regular" en una lista de cadenas / oraciones.

El compilador JIT no compila todo el código al código de la máquina. Compila código que tiene un patrón similar en tiempo de ejecución.

Consulte esta documentación de Oracle sobre Comprender JIT para leer más.

Tiene un código que se incluye en algunos IL (lenguaje intermedio). Cuando ejecuta su programa, la computadora no entiende este código. Solo entiende el código nativo. Entonces, el compilador JIT compila su IL en código nativo sobre la marcha. Hace esto a nivel de método.

Sé que este es un hilo viejo, pero la optimización del tiempo de ejecución es otra parte importante de la compilación JIT que no parece discutirse aquí. Básicamente, el compilador JIT puede monitorear el programa mientras se ejecuta para determinar formas de mejorar la ejecución. Luego, puede hacer esos cambios sobre la marcha, durante el tiempo de ejecución. Optimización de Google JIT (javaworld tiene un artículo bastante bueno al respecto ) .

Un compilador justo a tiempo (JIT) es una pieza de software que recibe una entrada no ejecutable y devuelve el código de máquina apropiado para su ejecución. Por ejemplo:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

La consecuencia de esto es que para una determinada arquitectura de CPU se debe instalar el compilador JIT apropiado.

Compilador de diferencias, intérprete y JIT

Aunque puede haber excepciones en general cuando queremos transformar el código fuente en código de máquina, podemos usar:

1. Compilador : toma el código fuente y devuelve un ejecutable
2. Intérprete : ejecuta la instrucción del programa por instrucción. Toma un segmento ejecutable del código fuente y convierte ese segmento en instrucciones de máquina. Este proceso se repite hasta que todo el código fuente se transforma en instrucciones de máquina y se ejecuta.
3. JIT : son posibles muchas implementaciones diferentes de un JIT, sin embargo, un JIT suele ser una combinación de un compilador y un intérprete. El JIT primero convierte los datos intermedios (por ejemplo, el código de bytes de Java) que recibe en lenguaje de máquina mediante interpretación. Un JIT a menudo puede detectar cuando una cierta parte del código se ejecuta a menudo y compilará esta parte para una ejecución más rápida.

Jit significa compilador justo a tiempo. Jit es un programa que convierte el código de bytes de Java en instrucciones que se pueden enviar directamente al procesador.

El uso del compilador de Java justo a tiempo (realmente un segundo compilador) en la plataforma de sistema particular cumple el código de bytes en un código de sistema particular, una vez que el compilador jit vuelve a compilar el código, generalmente se ejecutará más rápidamente en la computadora.

El compilador justo a tiempo viene con la máquina virtual y se usa opcionalmente. Compila el código de bytes en código ejecutable específico de la plataforma que se ejecuta de inmediato.

La compilación just-in-time (JIT), (también traducción dinámica o compilación en tiempo de ejecución ), es una forma de ejecutar código informático que implica la compilación durante la ejecución de un programa, en tiempo de ejecución, en lugar de antes de la ejecución .

La compilación de TI es una combinación de los dos enfoques tradicionales de traducción al código de máquina: compilación anticipada (AOT) e interpretación , y combina algunas ventajas y desventajas de ambos. La compilación JIT combina la velocidad del código compilado con la flexibilidad de interpretación .

Consideremos JIT utilizado en JVM,

Por ejemplo, los compiladores HotSpot JVM JIT generan optimizaciones dinámicas. En otras palabras, toman decisiones de optimización mientras se ejecuta la aplicación Java y generan instrucciones de máquina nativa de alto rendimiento destinadas a la arquitectura del sistema subyacente.

Cuando se elige un método para la compilación, la JVM alimenta su código de bytes al compilador Just-In-Time (JIT). El JIT necesita comprender la semántica y la sintaxis del bytecode antes de poder compilar el método correctamente. Para ayudar al compilador JIT a analizar el método, sus códigos de bytes se reformulan primero en una representación interna llamada árboles de rastreo, que se asemeja más al código de máquina que al código de bytes. El análisis y las optimizaciones se realizan en los árboles del método. Al final, los árboles se traducen al código nativo.

Un árbol de rastreo es una estructura de datos que se utiliza en la compilación en tiempo de ejecución del código de programación. Los árboles de rastreo se utilizan en un tipo de 'compilador justo a tiempo' que rastrea el código que se ejecuta durante los puntos calientes y lo compila. Consulte este .

Consulte:

• http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
• https://en.wikipedia.org/wiki/Just-in-time_compilation

Un compilador que no es JIT toma el código fuente y lo transforma en código de bytes específico de la máquina en el momento de la compilación. Un compilador JIT toma el código de bytes agnóstico de la máquina que se generó en el momento de la compilación y lo transforma en código de bytes específico de la máquina en el tiempo de ejecución. El compilador JIT que utiliza Java es lo que permite que un solo binario se ejecute en una multitud de plataformas sin modificación.

El 20% del código de bytes se usa el 80% del tiempo. El compilador JIT obtiene estas estadísticas y optimiza este 20% del código de bytes para que se ejecute más rápido al agregar métodos en línea, eliminar bloqueos no utilizados, etc. y también crear el código de bytes específico para esa máquina. Estoy citando este artículo, me pareció útil. http://java.dzone.com/articles/just-time-compiler-jit-hotspot

JIT se refiere al motor de ejecución en pocas implementaciones de JVM, uno que es más rápido pero requiere más memoria, es un compilador justo a tiempo. En este esquema, los códigos de bytes de un método se compilan en código máquina nativo la primera vez que se invoca el método. El código de máquina nativo para el método se almacena en caché, por lo que puede reutilizarse la próxima vez que se invoque el mismo método.

JVM realmente realiza pasos de compilación durante el tiempo de ejecución por razones de rendimiento. Esto significa que Java no tiene una separación de compilación-ejecución limpia. Primero realiza una compilación estática llamada del código fuente de Java a bytecode. Luego, este código de bytes se pasa a la JVM para su ejecución. Pero la ejecución de bytecode es lenta, por lo que la JVM mide con qué frecuencia se ejecuta el bytecode y cuando detecta un "punto de acceso" del código que se ejecuta con mucha frecuencia, realiza una compilación dinámica del código de byte al código de máquina del código de "punto de acceso". Así que, efectivamente, hoy los programas Java se ejecutan mediante ejecución de código de máquina.

El compilador Just In Time, también conocido como compilador JIT, se utiliza para mejorar el rendimiento en Java. Está habilitado por defecto. Es una compilación realizada en tiempo de ejecución bastante antes. Java ha popularizado el uso del compilador JIT incluyéndolo en JVM.