Naar inhoud springen

Bytecode: verschil tussen versies

Uit Wikipedia, de vrije encyclopedie
Verwijderde inhoud Toegevoegde inhoud
programma's uitvoeren op een GPU is ook een ding tegenwoordig
Intro correcter bijgesteld aan de hand van bronnen Stanford University en Lenovo + voorbeeldcode van bytecode
Regel 1: Regel 1:
'''Bytecode''' is een platform-onafhankelijke [[Interne representatie|high-level IR]]-code afkomstig van een [[computerprogramma]] dat door een compiler is [[compiler|gecompileerd]] tot [[Stack (informatica)|stapelgebaseerde]] machinearchitectuur.<ref name="stanford">{{Citeer web | url=https://suif.stanford.edu/dragonbook/lecture-notes/Stanford-CS143/16-Intermediate-Rep.pdf|titel=Intermediate Representation - Java Byte Code|auteur=Handout written by Maggie Johnson and revised by Julie Zelenski|via=[[Stanford University]]}}</ref> In tegenstelling tot [[machinetaal]] is een bytecode nog niet geschikt om direct door een [[Processor (computer)|processor]] te worden uitgevoerd, maar zal een [[virtuele machine]] de bytecode systematisch omzetten tot [[binaire code]]. Deze benadering maakt het mogelijk om dezelfde compilatie op meerdere machines en [[platform (informatica)|platforms]] uit te voeren waarop de vereiste Virtuele Machine is geïnstalleerd.<ref name="lenovo">{{Citeer web | url=https://www.lenovo.com/us/en/glossary/compilation/|titel=What is compilation?|werk=[[Lenovo]]}}</ref> Een voorbeeld is een compilatie van een [[C Sharp|C#]]-compiler voor [[.NET]] Common Language Runtime of een compilatie met [[javac]]-compiler voor [[Java Virtual Machine]].
'''Bytecode''' is een soort [[machinetaal]] die het resultaat is van de (gedeeltelijke) [[compiler|compilatie]] van een computerprogramma. In tegenstelling tot "echte" machinetaal is bytecode niet geschikt om direct op een processor te worden uitgevoerd.
Bytecode kan worden uitgevoerd op een [[virtuele machine]] (zoals de [[.NET]] Common Language Runtime (CLR) of de [[Java Virtual Machine]]) of later vertaald worden naar "echte" machinetaal.


== Voorbeeld ==
Deze benadering maakt het mogelijk platform-onafhankelijke programma's te schrijven: op elk [[platform (informatica)|platform]] waarvoor een Virtuele Machine beschikbaar is, kan dan hetzelfde programma worden uitgevoerd.
Een basisvoorbeeld van [[Java (programmeertaal)|Java]] bytecode door een [[javac]]-compiler met output ''Hello world'':<ref name="stanford" />

{|
|- style="vertical-align:top"
|
Method Main()
0 aload_0
1 invokespecial #1 <Method java.lang.Object()>
4 return
Method void main(java.lang.String[])
0 getstatic #2 <Field java.io.PrintStream out>
3 ldc #3 <String "Hello world">
5 invokevirtual #4 <Method void println(java.lang.String)>
8 return
|}

Het is vrij duidelijk te zien dat een gegenereerde bytecode dichter aanleunt bij een [[broncode]] ten opzichte van een andere intermediaire taalcode zoals [[objectcode]] dat meteen tot binaire gegevens en hexadecimale referenties wordt [[Assembler (software)|geassembleerd]]. Een Intermediaire Representatie dat dichter aanleunt bij machinecode wordt een Low-level IR-code genoemd.<ref name="stanford" />


== Voor- en nadelen van bytecode ==
== Voor- en nadelen van bytecode ==
Een vaak genoemd nadeel van bytecode is dat het langzamer zou zijn dan het uitvoeren van machinecode; de machinecode kan immers direct door de processor worden uitgevoerd. Indien bytecode wordt 'geïnterpreteerd', dan zal deze inderdaad trager zijn (soms wel tot een factor 20) dan machinecode. Indien de bytecode echter van tevoren zou worden omgezet naar machinecode is deze theoretisch gezien even snel. In de [[Java Virtual Machine]] wordt [[just-in-timecompilatie]] en interpretatie door elkaar gebruikt (just in time voor de kritieke, vaak aangeroepen stukken bytecode).
Een vaak genoemd nadeel van bytecode is dat het langzamer zou zijn dan het uitvoeren van machinecode; de machinecode kan immers direct door de processor worden uitgevoerd. Indien bytecode wordt 'geïnterpreteerd', dan zal deze inderdaad trager zijn (soms wel tot een factor 20) dan machinecode. Indien de bytecode echter van tevoren zou worden omgezet naar machinecode is deze theoretisch gezien even snel. In de [[Java Virtual Machine]] wordt [[just-in-timecompilatie]] en interpretatie door elkaar gebruikt (just in time voor de kritieke, vaak aangeroepen stukken bytecode).<ref name="lenovo" />


Een voordeel van bytecode is naast platformonafhankelijkheid dat het in principe specifiek te optimaliseren is voor de hardware waar het op draait. Stel dat een programma geschreven in machinecode is gemaakt voor een bepaalde processor met een snelle instructie X (bijvoorbeeld [[Intel]]s [[SSE]]-instructies), dan kunnen processors zonder deze instructie X het programma niet uitvoeren, en moet het programma zo worden gecompileerd dat de snelle instructie X niet voorkomt en wordt vervangen door een aantal langzamere instructies die wél op alle processoren werken. Een compiler in een virtual machine zou pas bij compilatie kunnen kijken welke instructies beschikbaar zijn en de bytecode automatisch kunnen omzetten naar de snelste instructies die beschikbaar zijn op de processor.
Een voordeel van bytecode is naast platformonafhankelijkheid dat het in principe specifiek te optimaliseren is voor de hardware waar het op draait. Stel dat een programma geschreven in machinecode is gemaakt voor een bepaalde processor met een snelle instructie X (bijvoorbeeld [[Intel]]s [[SSE]]-instructies), dan kunnen processors zonder deze instructie X het programma niet uitvoeren, en moet het programma zo worden gecompileerd dat de snelle instructie X niet voorkomt en wordt vervangen door een aantal langzamere instructies die wél op alle processoren werken. Een compiler in een virtual machine zou pas bij compilatie kunnen kijken welke instructies beschikbaar zijn en de bytecode automatisch kunnen omzetten naar de snelste instructies die beschikbaar zijn op de processor.
Regel 13: Regel 29:
* [[Classfile|Java bytecode]]
* [[Classfile|Java bytecode]]


{{Appendix}}
{{Navigatie compiler}}
{{Navigatie compiler}}



Versie van 6 apr 2024 00:22

Bytecode is een platform-onafhankelijke high-level IR-code afkomstig van een computerprogramma dat door een compiler is gecompileerd tot stapelgebaseerde machinearchitectuur.[1] In tegenstelling tot machinetaal is een bytecode nog niet geschikt om direct door een processor te worden uitgevoerd, maar zal een virtuele machine de bytecode systematisch omzetten tot binaire code. Deze benadering maakt het mogelijk om dezelfde compilatie op meerdere machines en platforms uit te voeren waarop de vereiste Virtuele Machine is geïnstalleerd.[2] Een voorbeeld is een compilatie van een C#-compiler voor .NET Common Language Runtime of een compilatie met javac-compiler voor Java Virtual Machine.

Voorbeeld

Een basisvoorbeeld van Java bytecode door een javac-compiler met output Hello world:[1]

Method Main()
0 aload_0
1 invokespecial #1 <Method java.lang.Object()>
4 return
Method void main(java.lang.String[])
0 getstatic #2 <Field java.io.PrintStream out>
3 ldc #3 <String "Hello world">
5 invokevirtual #4 <Method void println(java.lang.String)>
8 return

Het is vrij duidelijk te zien dat een gegenereerde bytecode dichter aanleunt bij een broncode ten opzichte van een andere intermediaire taalcode zoals objectcode dat meteen tot binaire gegevens en hexadecimale referenties wordt geassembleerd. Een Intermediaire Representatie dat dichter aanleunt bij machinecode wordt een Low-level IR-code genoemd.[1]

Voor- en nadelen van bytecode

Een vaak genoemd nadeel van bytecode is dat het langzamer zou zijn dan het uitvoeren van machinecode; de machinecode kan immers direct door de processor worden uitgevoerd. Indien bytecode wordt 'geïnterpreteerd', dan zal deze inderdaad trager zijn (soms wel tot een factor 20) dan machinecode. Indien de bytecode echter van tevoren zou worden omgezet naar machinecode is deze theoretisch gezien even snel. In de Java Virtual Machine wordt just-in-timecompilatie en interpretatie door elkaar gebruikt (just in time voor de kritieke, vaak aangeroepen stukken bytecode).[2]

Een voordeel van bytecode is naast platformonafhankelijkheid dat het in principe specifiek te optimaliseren is voor de hardware waar het op draait. Stel dat een programma geschreven in machinecode is gemaakt voor een bepaalde processor met een snelle instructie X (bijvoorbeeld Intels SSE-instructies), dan kunnen processors zonder deze instructie X het programma niet uitvoeren, en moet het programma zo worden gecompileerd dat de snelle instructie X niet voorkomt en wordt vervangen door een aantal langzamere instructies die wél op alle processoren werken. Een compiler in een virtual machine zou pas bij compilatie kunnen kijken welke instructies beschikbaar zijn en de bytecode automatisch kunnen omzetten naar de snelste instructies die beschikbaar zijn op de processor.

Zie ook