Usuari:Mcapdevila/Compilació en temps d'execució

En informàtica, la compilació en temps d'execució (referida amb les sigles angleses, JIT , just-in-time ), o també coneguda com traducció dinàmica , és una tècnica per millorar el rendiment de sistemes de programació que compilen a bytecode , consistent a traduir el bytecode a codi màquina natiu en temps d'execució. La compilació en temps d'execució es construeix a partir de dues idees anteriors relacionades amb els entorns d'execució: la compilació bytecode i la compilació dinàmica .

En un sistema que utilitzi compilació bytecode com ara Smalltalk, Perl, GNU CLISP o les primeres versions de Java, el codi font és traduït a un codi intermedi anomenat bytecode . El bytecode no és el codi màquina de cap ordinador en particular, i pot per tant ser portable entre diferents arquitectures. El bytecode és llavors interpretat, o executat per una màquina virtual.

Un entorn amb compilació dinàmica és aquell en què el compilador pot ser usat durant l'execució. Per exemple, la majoria dels sistemes Commons Lisp tenen una funció compili que permet compilar noves funcions creades durant l'execució del programa. Encara avantatjós en la depuració interactiva, la compilació dinàmica és menys útil en un sistema en explotació desatès. Aquest mètode és més comú en emuladors moderns i freqüentment comercials que requereixen molta velocitat, com el Qemu i el VirtualPC (PC) o el executor (Macintosh 68k).

En un entorn de compilació en temps d'execució, la compilació bytecode és el primer pas, reduint el codi font a una representació intermèdia portable i optimizable. El bytecode es desplega en el sistema de destinació. Quan aquest codi s'executa, el compilador en temps d'execució el tradueix a codi màquina natiu. Això es pot fer a nivell de fitxer (programa) o de funcions, compilándose en aquest últim cas el codi corresponent a una funció just quan va a executar (d'aquí el nom de just-in-time , «just a temps»).

L'objectiu és combinar moltes de les avantatges de la compilació a codi natiu i bytecode : la majoria del «treball pesat» de processar el codi font original i realitzar optimitzacions bàsiques es realitza en el moment de compilar a bytecode , molt abans del desplegament: així, la compilació a codi màquina del programa és molt més ràpida que partint del codi font. El bytecode desplegat és portable, a diferència del codi màquina per a qualsevol arquitectura concreta. Els compiladors dinàmics són més fàcils d'escriure, ja que el compilador a bytecode ja fa bona part del treball.

Ús de compilació JIT en emuladors

Al moment d'emular la CPU, el programa tradueix el codi màquina del programari emulat en codi natiu de la màquina emuladora i l'escriu en una memòria cau amb permisos d'execució i escriptura (generalment en UNIX o en sistemes compatibles amb POSIX s'assigna aquest permís amb la funció mprotect ()). La traducció s'atura quan es troba qualsevol instrucció que provoqui un canvi en el comptador de programa, com una interrupció, una instrucció de salt o una trucada a subrutina i és interpretat com un retorn de rutina al compilador o altres tasques del programa. Després l'emulador s'executa el codi contingut a la memòria cau.

L'avantatge d'aquest mètode és que si la mida de la memòria cau és gran, l'emulador no necessita recompilar el codi, el que augmenta molt la velocitat. No obstant això, sorgeixen problemes quan el programa emulat escriu el seu codi, i cal tornar a recompilar aquest codi, llevat que el codi emulat tingui permisos de només lectura, per exemple en sistemes UNIX amb memòria protegida.