Ricompilazione dinamica

In informatica la ricompilazione dinamica è una tecnica di ottimizzazione implementata da molti emulatori e macchine virtuali. Questa tecnica prevede che il codice sorgente di un programma venga analizzato durante la sua esecuzione e ricompilato al fine di renderlo eseguibile e/o di migliorarne le prestazioni d'esecuzione. La compilazione durante l'esecuzione permette di adattare il codice alla macchina che lo sta eseguendo tenendo conto anche delle informazioni presenti durante l'esecuzione, informazioni che un compilatore non possiede durante la classica compilazione statica.

In alcuni casi la ricompilazione dinamica viene utilizzata in congiunzione con altre tecniche di ottimizzazione adattativa per migliorare l'esecuzione di codice portabile, codice indipendente dalla piattaforma. Per esempio spesso le macchine virtuali Java e il .NET Common Language Runtime quando eseguono il bytecode fanno uso di questa tecnica.

Esempio

Supponiamo di avere un programma in esecuzione su un emulatore e che il programma debba effettuare la copia di una stringa terminata con un carattere NULL. Il programma è stato compilato per un processore molto semplice, questo è in grado di copiare un singolo byte per volta, il programma legge il byte da un registro e provvede a copiarlo nella stringa di destinazione. Il programma originario avrebbe un codice simile al seguente:

inizio:
    mov A,[first string pointer]    ; Put location of first character of source string
                                    ; in register A
    mov B,[second string pointer]   ; Put location of first character of destination string
                                    ; in register B
loop:
    mov C,[A]            ; Copy byte at address in register A to register C
    mov [B],C            ; Copy byte in register C to the address in register B
    inc A                ; Increment the address in register A to point to
                         ; the next byte
    inc B                ; Increment the address in register B to point to
                         ; the next byte
    cmp C,#0             ; Compare the data we just copied to 0 (string end marker)
    jnz loop             ; If it wasn't 0 then we have more to copy, so go back
                         ; and copy the next byte
fine:                     ; If we didn't loop then we must have finished,
                         ; so carry on with something else.

L'emulatore è eseguito da un processore più potente di quello utilizzato per sviluppare il codice appena indicato. Questo processore dispone di istruzioni appositamente progettate per copiare le stringhe e l'emulatore è a conoscenza di queste istruzioni. L'emulatore tramite la tecnica di ricompilazione dinamica potrebbe riconoscere il frammento di codice che copia la stringa e potrebbe sostituirlo con del codice che si avvantaggia delle nuove istruzioni presenti sul processore. Tra le nuove istruzioni supponiamo che vi sia l'istruzione "movs", questa provvede a copiare fino a 16 byte contemporaneamente, senza dover utilizzare un registro di parcheggio e si ferma se incontra il carattere NULL.

Il nuovo codice con la ricompilazione dinamica avrebbe la seguente forma:

inizio:
    mov A,[first string pointer]    ; Put location of first character of source string
                                    ; in register A
    mov B,[second string pointer]   ; Put location of first character of destination string
                                    ; in register B
loop:
    movs [B],[A]            ; Copy 16 bytes at address in register A to address
                            ; in register B, then increment A and B by 16
    jnz loop                ; If the zero flag isn't set then we haven't reached
                            ; the end of the string, so go back and copy some more.
fine:                        ; If we didn't loop then we must have finished,
                            ; so carry on with something else.

Questo codice è più compatto e molto più veloce dato che evita una copia intermedia nei registri del processori. Inoltre l'istruzione "movs" sarà probabilmente stata sviluppata in modo da essere più veloce di 16 mov singole.

Prodotti con ricompilazione dinamica

• Molte macchine virtuali Java (vedi Compilatore just-in-time)
• Il programma Rosetta fornito da Apple per permettere alle macchine X86 di eseguire codice PowerPC.
• Il precedente programma Mac 68K utilizzato da Apple per permettere alla macchine PowerPC di eseguire codice 68000.
• Psyco un compilatore per Python.
• La machina virtuale VX32.
• Virtual PC
• QEMU
• L'emulatore incluso nella Xbox 360 che permette l'esecuzione di giochi della precedente Xbox si presuppone che utilizzi la ricompilazione dinamica.
• L'emulatore della console Nintendo GameCube Dolphin-Emu
• OVPsim

Collegamenti esterni

• (EN) HP Labs' technical report on Dynamo, su hpl.hp.com. URL consultato il 6 settembre 2008 (archiviato dall'url originale il 7 luglio 2008).