Compilarea just-in-time este o metodă de îmbunătățire a performanței programelor interpretate. În timpul execuției, programul poate fi compilat în cod nativ pentru a-și îmbunătăți performanța. Este, de asemenea, cunoscut sub numele de compilare dinamică.

Compilația dinamică are unele avantaje față de compilația statică. Când rulați aplicații Java sau C #, mediul de execuție poate profila aplicația în timp ce este rulată. Acest lucru permite generarea unui cod mai optimizat. Dacă comportamentul aplicației se schimbă în timp ce rulează, mediul de execuție poate recompila codul.

Unele dintre dezavantaje includ întârzierile la pornire și cheltuielile generale de compilare în timpul rulării. Pentru a limita cheltuielile generale, multe compilatoare JIT compilează doar căile de cod utilizate frecvent.

Prezentare generală

În mod tradițional, există două metode pentru conversia codului sursă într-un formular care poate fi rulat pe o platformă. Compilația statică convertește codul într-un limbaj pentru o anumită platformă. Un interpret execută direct codul sursă.

Compilația JIT încearcă să utilizeze beneficiile ambelor. În timp ce programul interpretat este rulat, compilatorul JIT determină codul cel mai frecvent utilizat și îl compilează în codul mașinii. În funcție de compilator, acest lucru se poate face pe o metodă sau o secțiune mai mică de cod.

Compilația dinamică a fost descrisă pentru prima dată într-o lucrare de J. McCarthy despre LISP în 1960.

Compilația Just In Time, JIT sau Traducere dinamică, este o compilație care se face în timpul executării unui program. Înțeles, în timpul rulării, spre deosebire de anterior executării. Ceea ce se întâmplă este traducerea în codul mașinii. Avantajele unui JIT se datorează faptului că, din moment ce compilarea are loc în timp de execuție, un compilator JIT are acces la informații dinamice de rulare, permițându-i să facă optimizări mai bune (cum ar fi funcțiile de integrare).

Ceea ce este important de înțeles despre compilația JIT este că va compila codul secundar în instrucțiunile codului mașinii de pe mașina care rulează. Adică, codul mașinii rezultate este optimizat pentru arhitectura procesorului mașinii care rulează.

Câteva exemple de compilatoare JIT sunt JVM (Java Virtual Machine) în Java și CLR (Common Language Runtime), în C #.

Istorie

La început, un compilator a fost responsabil pentru transformarea unui limbaj de nivel înalt (definit ca nivel mai înalt decât ansamblorul) în cod obiect (instrucțiuni ale mașinii), care ar fi apoi legat (de un linker) într-un executabil.

La un moment dat în evoluția limbajelor, compilatoarele ar compila un limbaj de nivel înalt în pseudo-cod, care ar fi apoi interpretat (de către un interpret) pentru a rula programul. Acest lucru a eliminat codul obiectului și executabilele și a permis acestor limbaje să fie portabile pe mai multe sisteme de operare și platforme hardware. Pascal (care a compilat P-Code) a fost unul dintre primii; Java și C # sunt exemple mai recente. În cele din urmă, termenul P-Code a fost înlocuit cu bytecode, deoarece majoritatea pseudo-operațiilor au un octet lung.

Un compilator Just-In-Time (JIT) este o caracteristică a interpretului în timp de execuție, care, în loc să interpreteze codul secundar de fiecare dată când este invocată o metodă, va compila codul secundar în instrucțiunile codului mașinii ale mașinii care rulează și apoi va invoca acest lucru codul obiectului în schimb. În mod ideal, eficiența executării codului obiect va depăși ineficiența recompilării programului de fiecare dată când rulează.

Scenariu tipic

Codul sursă este complet convertit în cod mașină

Scenariul JIT

Codul sursă va fi convertit în limbaj de asamblare, cum ar fi structura [for ex IL (intermediate language) for C#, ByteCode for java].

Codul intermediar este convertit în limbajul mașinii numai atunci când cerințele cererii cerute sunt convertite numai în cod mașină.

Comparație JIT vs Non-JIT

În JIT nu tot codul este convertit în cod mașină, mai întâi o parte din cod necesară va fi convertită în cod mașină, apoi dacă o metodă sau funcționalitate numită nu este în mașină, atunci aceasta va fi transformată în cod mașină, ceea ce reduce sarcina asupra CPU. Deoarece codul mașinii va fi generat în timpul rulării, compilatorul JIT va produce codul mașinii care este optimizat pentru a rula arhitectura procesorului mașinii.

Câteva exemple de JIT sunt:

  • Java: JVM (mașină virtuală Java)
  • C #: CLR (Common Language Runtime)
  • Android: DVM (Dalvik Virtual Machine) sau ART (Android RunTime) în versiuni mai noi

Mașina virtuală Java (JVM) execută bytecode și menține un număr de câte ori este executată o funcție. Dacă acest număr depășește o limită predefinită, JIT compilează codul în limbajul mașinii, care poate fi executat direct de procesor (spre deosebire de cazul normal în care javac compilează codul în bytecode și apoi Java, interpretul interpretează acest bytecode linie cu linie îl convertește în codul mașinii și se execută).

De asemenea, data viitoare când se calculează această funcție, același cod compilat este executat din nou, spre deosebire de interpretarea normală în care codul este interpretat din nou rând cu rând. Acest lucru face ca execuția să fie mai rapidă.