Just-In-Time-compilatie, of JIT, is een techniek die wordt gebruikt door runtime-interpreters voor talen zoals JavaScript, C# en Java om uitvoeringssnelheden dichter bij de native prestaties te brengen die worden geboden door vooraf gecompileerde binaire talen zoals C++.
Compilers vs. Tolken
Computers weten niet hoe ze programmeertalen op hoog niveau zoals C++ moeten uitvoeren, althans niet rechtstreeks. Om door mensen leesbare code te vertalen naar iets dat uw CPU kan uitvoeren, moet deze worden geconverteerd. Een computer doet dit meestal via een van de twee methoden: compilatie of interpretatie.
Compilatie omvat het uitvoeren van een compiler, een programma dat de broncode neemt en deze omzet in binaire machinecode, voordat de toepassing wordt uitgevoerd. De compilatie vindt plaats op de computer van de ontwikkelaar voordat deze wordt verpakt en verzonden. De meeste uitvoerbare bestanden die u downloadt, zijn op een bepaald niveau gecompileerd om op uw machine te draaien, en gecompileerde code is meestal vrij snel omdat de compiler optimalisaties kan maken voor uw specifieke machine.
Compilers hebben echter een paar nadelen. Programma's moeten worden gecompileerd voor specifieke CPU-instructiesets (zoals x86-64 of ARM). Bovendien moeten zelfs besturingssystemen die instructiesets delen (zoals Windows en Linux, die beide op Intel CPU's draaien) programma's afzonderlijk hebben gecompileerd vanwege de vele verschillen in hoe ze werken.
Dit betekent dat voor iets als JavaScript, dat via internet naar verbonden clients moet worden verzonden, het niet van tevoren kan worden gecompileerd, omdat de client elke combinatie van instructieset en besturingssysteem kan gebruiken.
Tolken pakken het anders aan. Een tolk is in feite een softwarerobot die de broncode van een programma, zoals een JavaScript- of Python-script, neemt en de uitvoering tijdens runtime uitvoert. Het fungeert in wezen als een middelste laag tussen de broncode en de machine, waar een compiler het rechtstreeks zou vertalen.
Dit heeft het grote voordeel dat het programma niet voor een bepaalde machine hoeft te worden gebouwd; zolang de machine de Python-interpreter kan uitvoeren, kan deze alle Python-scripts uitvoeren.
Wat doet JIT-compilatie?
Helaas voor tolken zijn ze traag. Een echte tolk moet elke afzonderlijke instructie vertalen en afhandelen, in wezen het werk van een compiler voor elke uitvoering. Dat is veel overhead, dus in werkelijkheid maken de meeste tolken, zoals de V8 JavaScript-engine, de Java Virtual Machine (JVM) en .NET's Common Language Runtime gebruik van Just-In-Time-compilatie om de snelheid te verhogen. de tolk omhoog.
Just-In-Time-compilatie is in wezen een compiler die uitstelgedrag vertoont en de code voor elke functie alleen compileert wanneer dat nodig is. Telkens wanneer u een functie aanroept, en de JIT-compiler deze nog niet heeft gezien, zal deze die functie compileren (waarbij eventuele optimalisaties worden toegepast voor de machine waarop deze wordt uitgevoerd) en deze uitvoeren. De volgende keer dat u de functie aanroept, heeft hij de machinecode al bij de hand, dus hij hoeft deze alleen maar op te zoeken in de cache.
Just-In-Time verwijst naar het feit dat de interpreter dat niet doet. 8217; je hoeft niet de hele app in één keer te compileren. Het zou zeker kunnen, maar voor een grote app zou het leiden tot zeer hoge opstarttijden. Het is beter voor de prestaties om alleen te compileren wanneer het nodig is (dat wil zeggen, net op tijd).
Heeft JIT Compilation een prestatiehit?
JIT is letterlijk slechts een prestatieverbetering ten opzichte van reguliere tolken, dus vergeleken met het helemaal niet doen, is het veel sneller. Het compileren van code is echter niet bijzonder snel, dus het is duidelijk dat het compileren tijdens runtime gepaard gaat met een prestatiehit in vergelijking met het vooraf rechtstreeks compileren naar bytecode.
Advertentie
Echter, omdat JIT-compilatie meestal hoeft alleen te worden uitgevoerd de eerste keer dat een functie wordt aangeroepen, veelgebruikte functies zullen pas echt een prestatiehit zien bij de eerste aanroep. Je kunt dit testen in C# met StopWatches: ze pikken .NET “achtergrondruis op,” inclusief de tijd die besteed wordt aan JIT-compilatie bij de eerste uitvoering van een functie.
Het belangrijkste nadeel van door JIT gecompileerde applicaties is een hoge koude opstarttijd, aangezien duizenden functies die bij het opstarten worden aangeroepen, direct aan het begin moeten worden gecompileerd . Bij sommige ASP.NET-webapplicaties kan het meer dan een minuut duren voordat ze zijn opgestart, deels vanwege de hoge belasting van de JIT-compiler in het begin.