Wikipedia

GraalVM

Macchina virtuale

GraalVM è una Macchina Virtuale Java (JVM o Java VM) e Java Development Kit (JDK) basata su HotSpot/OpenJDK, implementata in Java. Supporta molteplici linguaggi di programmazione e modalità di esecuzione, come, ad esempio, la compilazione ahead-of-time (AOT) di applicazioni Java per diminuire il tempo di avvio e ridurre l'impatto sulla memoria. La prima versione commerciale, GraalVM 19.0, è stata rilasciata nel maggio 2019.[1]

GraalVM
software
Logo
Logo
GenereMacchina virtuale
SviluppatoreOracle Corporation
Data prima versione9 Maggio 2019
Ultima versione19.3.0 (20 novembre 2019) e 23.0.0 (13 giugno 2023)
Sistema operativoLinux
Microsoft Windows
macOS
LinguaggioJava
LicenzaGraalVM Community Edition: GPLv2

Oracle GraalVM: GFCT
(licenza libera)

Sito webwww.graalvm.org

L'edizione più recente di GraalVM è la 19.3.0 (20 novembre 2019) e 23.0.0 (13 giugno 2023). È disponibile in due versioni: GraalVM per JDK 17, GraalVM per JDK 20.[2]

GraalVM presenta molteplici differenze rispetto ad una versione standard del JDK[3]:

  • Compilatore GraalVM, un compilatore just-in-time (JIT) per Java
  • GraalVM Native Image, un componente che permette la compilazione ahead-of-time per applicazioni Java
  • Piattaforma di implementazione linguaggi Truffle e SDK GraalVM che permettono di aggiungere nuovi runtime per linguaggi di programmazione
  • Runtime per LLVM e JavaScript

Storia modifica

GraalVM nasce dal progetto Maxine VM ai laboratori Sun Microsystems (tuttora Oracle Labs). Lo scopo era quello di scrivere una macchina virtuale Java attraverso Java stesso, con lo scopo di rimuovere dallo sviluppo software i problemi tipici di C++, in particolare la gestione manuale della memoria, e beneficiare di particolari ottimizzazioni.[4] Una volta realizzato che questo rappresentava un primo passo troppo ambizioso, fu presa la decisione di focalizzarsi solamente sul compilatore e collegarlo ad HotSpot, riutilizzando così il più possibile il runtime di HotSpot. Il compilatore GraalVM vede i suoi albori da una conversione manuale del codice client del compilatore HotSpot in Java (chiamato "C1"), rimpiazzando il precedente compilatore Maxine.[5]

Lo scopo generale del progetto è quindi diventato:

  • Aumentare le performance di linguaggi basati sulla Java VM per raggiungere i livelli di linguaggi nativi.[3][6]
  • Ridurre il tempo di avvio di applicazioni basate su JVM compilandole ahead-of-time attraverso la tecnologia GraalVM Native Image.[7]
  • Permettere l'integrazione di GraalVM all'interno, ad esempio, di Oracle DB, OpenJDK, Node.js, Android/iOS.[8][9][10][11]
  • Creare una piattaforma dove sia possibile combinare in maniera libera qualsiasi linguaggio di programmazione in un unico programma definito "programma poliglotto".[3][12]
  • Includere un insieme di strumenti per lo sviluppo software poliglotto facilmente estendibili.[3][13]

Graal è stato incluso all'interno delle versioni di macchine virtuali Java basate su HotSpot, come OpenJDK, da Java 9 fino a Java 15. Questo per supportare la compilazione sperimentale ahead-of-time. L'opzione UseJVMCICompiler permetteva inoltre di utilizzare JIT come rimpiazzo per C2.[14] Questa opzione è stata rimossa con Java 16 in quanto mantenere entrambe le versioni all'interno del JDK e nelle edizioni stand-alone di GraalVM avrebbe richiesto il doppio dello sforzo.[15] Una funzionalità simile per creare eseguibili nativi da progetti Java è permesso attraverso l'utilizzo dello strumento native-image di GraalVM.[7]

Edizioni modifica

Oracle Corporation ha annunciato il rilascio di Oracle GraalVM Enterprise Edition l'8 Maggio 2019.[16] Fino al 2023, GraalVM era disponibile come versione Community Edition (CE) con licenza GPLv2 e come Oracle GraalVM Enterprise Edition (EE) accettando un appropriato contratto di licenza chiamato GraalVM Oracle Technology Network.[17] L'edizione Enterprise del prodotto, oltre ad avere aggiornamenti di sicurezza, possiede ulteriori funzionalità aggiuntive non a disposizione dell'edizione Community.[18]

A partire dal 2023, le nuove edizioni di GraalVM Community Edition (CE) seguiranno i rilasci ogni sei mesi del JDK.[19] Inoltre, il nome delle versioni sarà associato alla versione del JDK al quale GraalVM fa riferimento, ad esempio GraalVM per JDK 17. La versione GraalVM Enterprise Edition invece cambia nome e diventa Oracle GraalVM. Con questo cambiamento viene aggiornata anche la licenza che diventa GraalVM Free Terms and Conditions (GFTC).[20] Questa licenza permette gratuitamente di utilizzare Oracle GraalVM sia durante lo sviluppo che in ambienti commerciali a patto che i servizi costruiti con essa non vengano offerti a pagamento.[2]

GraalVM 23 (JDK 17 e 20) modifica

Rilasciata il 13 giugno 2023, è la prima edizione di GraalVM ad abbandonare la nomenclatura tradizionale associata all'anno di pubblicazione (ad esempio, l'anno 2022 corrispondeva alle edizioni 22.x.x di GraalVM).[2] Sono infatti disponibili due edizioni, GraalVM per JDK 17.0.7 e JDK 20.0.1.[21][22] In questo periodo transitorio è comunque possibile riferirsi alla versione GraalVM 23.0.0.[23] Entrambe le versioni supportano il Garbage Collector ZGC per computazioni che richiedono una bassa latenza o un utilizzo dell'heap elevato. Inoltre, è stato reso open-source Ideal Graph Visualizer (IGV) per permettere agli sviluppatori di linguaggi terzi di utilizzarlo e contribuire al suo sviluppo.[24]

GraalVM 22 modifica

  • GraalVM 22.3: Rilasciata nel ottobre 2022.[25] Questa edizione include il supporto al JDK 19, in quanto nelle successive versioni di GraalVM, il supporto a JDK 11 verrà deprecato.[26]
  • GraalVM 22.2: Rilasciata nel luglio 2022. Con questa edizione il JDK GraalVM è diventato modulare per ridurre le dimensioni dello stesso.[27] I runtime di JavaScript, LLVM e VisualVM non sono più inclusi nel JDK ma possono essere installati nella stessa maniera di quelli relativi a Python, Native Image e Ruby. In questa edizione, il supporto ad Apple Silicon è compreso anche nella versione Enterprise di GraalVM.[28]
  • GraalVM 22.1: Rilasciata nel aprile 2022. È stata introdotta una nuova modalità di creazione delle native-image chiamata quick-build che riduce ulteriormente il tempo necessario per la generazione.[29] Inoltre è stato rilasciato, per la Community Edition, il supporto in modalità sperimentale per Apple Silicon con l'edizione darwin-aarch64. Per quanto riguarda Python è stato invece aggiunto il supporto ai moduli frozen, che permette di diminuire ulteriormente il tempo di esecuzione e l'impatto sulla memoria del sistema.[30]
  • GraalVM 22.0: Rilasciata nel gennaio 2022. In questa edizione è stato completamente rimosso il supporto a Java 8, da questa edizione verranno solamente supportati i JDK 11 e 17. Sono stati effettuati dei cambiamenti per ridurre la dimensione delle native-image.[31] Inoltre è stata migliorata la descrizione a terminale del processo di creazione delle native-image.[32]

GraalVM 21 modifica

  • GraalVM 21.2: Rilasciata il 20 luglio 2021. È stata rilasciata la versione ufficiale del plugin per native-image di Gradle e Maven, con un supporto sperimentale per JUnit 5. È stato aggiunto un supporto base per Java Flight Recorder (JFR) per JDK 11.[33]
  • GraalVM 21.1: Rilasciata il 20 aprile 2021. Aggiunge il supporto sperimentale a JDK 16 per entrambe le versioni Enterprise e Community. Con questa edizione Node.js non è più incluso nella versione base di GraalVM, può essere installato a parte tramite un appropriato comando.[34]
  • GraalVM 21.0: Rilasciata il 19 gennaio 2021. Con questa versione viene aggiunta l'esecuzione in modalità sperimentale di Java come linguaggio implementato da Truffle. Inoltre è stata aggiunta la possibilità di utilizzare la serializzazione di Java all'interno dei binari native-image.[35]

GraalVM 20 modifica

  • GraalVM 20.3: Rilasciata nel novembre 2020. Questa è la prima versione con supporto a lungo termine (LTS) Enterprise di GraalVM e l'ultima per l'anno 2020. Questa versione supporta la condivisione di codice nel runtime LLVM di GraalVM, permettendo all'Abstract Syntax Tree (AST) e al codice compilato del bitcode delle librerie condivise di essere condiviso tra diversi contesti all'interno di un unico sistema.[36]
  • GraalVM 20.1: Rilasciata a maggio 2020. Include molti miglioramenti per vari componenti. Oltre ad aumentare le performance generali del sistema, sono state aggiunte delle semplificazioni nell'utilizzo della native-image di GraalVM. Il motore interno di JavaScript supporta tutte le funzionalità di ECMAScript 2020 in maniera standard. Il motore di parsing di espressioni regolari (TRegex) usato da JavaScript e Python supporta ora tutte le espressioni. Inoltre è stata migliorata la compatibilità alle native gems all'interno di Ruby (TruffleRuby).[37]
  • GraalVM 20.0: Rilasciata a febbraio 2020. All'interno di questa release è stato migliorato il supporto a Windows. Inoltre, sono stati migliorati gli strumenti della native-image e i relativi tool di supporto, insieme a cambiamenti all'interno del compilatore e dei linguaggi supportati.[38]

GraalVM 19 modifica

  • GraalVM 19.0: Il supporto per Windows di questa versione è ancora in fase di sviluppo ed è rilasciato come funzionalità disponibile per gli early-adopters. GraalVM 19.0 è basata sulla versione JDK 8u212.[39]

Componenti modifica

Il compilatore di GraalVM include i componenti di una normale macchina virtuale Java (in particolare OpenJDK). Alcuni componenti aggiuntivi sono inclusi in GraalVM per supportare le nuove modalità di esecuzione (GraalVM Native Image) o ulteriori linguaggi di programmazione come il runtime LLVM, GraalVM JavaScript (un potenziale rimpiazzo per il deprecato sistema Nashorn) e TRegex come sistema per espressioni regolari.[10][40][41]

 
Architettura interna della versione 22.3 di GraalVM Community Edition.

Compilatore GraalVM modifica

Il compilatore GraalVM è un moderno compilatore just-in-time scritto in Java. Si posiziona come complementare o, in alcuni casi come rimpiazzo, per i compilatori esistenti in HotSpot (C1/C2). In contrasto con i precedenti compilatori, il compilatore GraalVM è scritto in maniera modulare, mantenibile ed espandibile attraverso Java stesso.[42] Per permettere l'esecuzione di diversi linguaggi di programmazione all'interno della stessa JVM, il compilatore lavora con una rappresentazione intermedia (IR) comune dei linguaggi sotto forma di grafo. I passi eseguiti durante la compilazione sono i seguenti[43]:

  • Il codice e i dati (Albero sintattico astratto - AST) del framework Truffle sono valutati parzialmente per produrre un grafo di compilazione. Quando un AST è chiamato molte volte durante l'esecuzione del codice è programmato per essere messo in compilazione dal compilatore.
  • Il grafo di compilazione viene ottimizzato dal compilatore Graal per produrre codice macchina.
  • JVMCI installa questo codice macchina all'interno della cache di codice della VM.
  • L'AST ridirigerà automaticamente l'esecuzione verso il codice macchina installato in precedenza non appena questo sarà disponibile.

Questo compilatore è rilasciato con licenza GPL v2 con l'eccezione classpath.[42]

GraalVM Native Image modifica

GraalVM Native Image è una tecnologia di compilazione ahead-of-time che produce dai file delle classi degli eseguibili binari. È stata originariamente rilasciata come un plugin per early adopter, che significa che il prodotto è pronto al rilascio ma potrebbe includere delle parti non compatibili con futuri aggiornamenti.[44]

Questa funzionalità supporta tutti i linguaggi basati sulla JVM, ma può, in maniera opzionale, eseguire linguaggi dinamici costruiti attraverso la piattaforma Truffle di GraalVM. Il file non viene eseguito all'interno della JVM e usa i componenti necessari del runtime come lo scheduling dei thread o il Garbage Collector (GC) da una versione minimale della JVM chiamata Substrate VM. Dato che i binari nativi così ottenuti includono le classi delle applicazioni, le dipendenze del JDK e le librerie, il tempo di avvio e di esecuzione sono fortemente ridotti.[44]

GraalVM Native Image è ufficialmente supportata dai framework Fn, Gluon, Helidon, Micronaut, Picocli, Quarkus, Vert.x e SpringBoot Java.[41][45] Nel Settembre 2016, Oracle ha comunicato i suoi piani per aggiungere la compilazione ahead-of-time all'interno di OpenJDK utilizzando il compilatore GraalVM per Java 9.[46][47] Questa proposta, identificata dal JEP 295 "Ahead-of-Time Compilation", è stata inclusa all'interno di Java 9. L'uso in fase sperimentale di GraalVM come compilatore just-in-time è stato aggiunto per la piattaforma Linux x86-64 per Java 10.[48]

Nelle versioni del JDK dalla 9 alla 15, il comando jaot crea una Native Image di un progetto.[14] La configurazione sperimentale -XX:+EnableJVMCIProduct permette di attivare l'utilizzo del Graal JIT.[49] Questa funzionalità è attualmente disponibile nel componente native-image della versione stand-alone di GraalVM.[49]

Piattaforma di implementazione linguaggi Truffle modifica

Insieme a GraalVM, Oracle Labs ha sviluppato un interprete di linguaggio per AST, chiamato "Truffle". Questa piattaforma permette di implementare linguaggi sfruttando GraalVM.[50][51] Molteplici linguaggi sono stati implementati in Truffle, incluso un interprete C che afferma di essere veloce tanto quanto GCC e Clang.[52]

La piattaforma Truffle e le parti che dipendono da essa (GraalVM SDK) sono rilasciate con licenza Universal Permissive License v1, per incoraggiare l'uso della piattaforma per progetti che non vogliono essere legati dal copyright o altri diritti derivati.[53]

Supporto a strumenti di misurazione modifica

Uno dei maggiori vantaggi dell'ecosistema di GraalVM è il fatto di possedere degli strumenti, indipendenti dal linguaggio, dinamici e direttamente integrati nella VM, per misurare le prestazioni in modo tale da diagnosticare errori e ottenere informazioni di log interne.[54][55]

L'installazione di base di GraalVM consente, grazie al supporto della VM, l'utilizzo di debugger, di profilatori, di visualizzatore di heap e altri tool completamente indipendenti dal linguaggio utilizzato.[13] GraalVM include inoltre un'implementazione del backend del protocollo di debugging remoto di Chrome Inspector.[56] Anche se originariamente ideato per debugging di codice JavaScript, può essere utilizzato per debuggare tutti i linguaggi di GraalVM direttamente dal proprio browser.[56]

Linguaggi e runtime aggiuntivi modifica

GraalVM è sviluppato e permette di sviluppare nell'ecosistema di Java. Può eseguire applicazioni in tutti i linguaggi che compilano in un bytecode Java, come ad esempio: Java, Scala, Kotlin.[12]

Grazie al framework di implementazione linguaggi di Truffle sono stati supportati ulteriori linguaggi all'interno di GraalVM.

  • GraalVM JavaScript: un runtime aderente alle direttive ECMAScript 2021, con supporto per Node.js[57]
  • TruffleRuby: un'implementazione del linguaggio Ruby con un supporto preliminare a Ruby on Rails[58]
  • FastR: implementazione del linguaggio R[59]
  • GraalVM Python: implementazione del linguaggio Python 3[60]
  • GraalVM LLVM Runtime (SuLong): Interprete di bitcode LLVM[61]
  • GraalWasm: implementazione di WebAssembly[62]

Il supporto per linguaggi aggiuntivi può essere implementato dagli utenti di GraalVM. Alcuni linguaggi di terze parti rilevanti sono: GrCUDA[63][64][65], SOMns[66], TruffleSqueak[67][68] e Yona[69].

Programmazione poliglotta modifica

Uno dei vantaggi di GraalVM è la possibilità di scrivere applicazioni "poliglotte".[12] Questo significa che uno sviluppatore ha la possibilità di far interagire vari linguaggi di programmazione all'interno dello stesso codice sorgente, ottenendo di conseguenza i vantaggi caratteristici di ogni linguaggio. Tutto ciò è reso possibile grazie al framework di implementazione di linguaggi Truffle.[50]

Creazione di array modifica

Partendo dall'implementazione di uno dei linguaggi presenti in GraalVM è possibile dichiarare array all'interno del codice sorgenti in altri linguaggi di programmazione. L'interazione tra il linguaggio "locale" e quello "estraneo" è automaticamente gestita da Truffle. Negli snippet di codice seguenti, tratti dal manuale di GraalVM, è possibile osservare come utilizzare la programmazione poliglotta:[12]

Creazione di un array in R da JavaScript: 

var array = Polyglot.eval("R", "c(1,2,42,4)")
console.log(array[2]);

Creazione di un array Python da Java: 

import org.graalvm.polyglot.*;

class Polyglot {
    public static void main(String[] args) {
        Context context = Context.newBuilder().allowIO(true).build();
        Value array = context.eval("python", "[1,2,42,4]");
        int result = array.getArrayElement(2).asInt();
        System.out.println(result);
    }
}

Creazione di un array JavaScript da Python: 

import polyglot
array = polyglot.eval(language="js", string="[1,2,42,4]")
print(array[2])

Chiamata di funzioni modifica

Con Truffle, è anche possibile lanciare funzioni scritte in diversi linguaggi di programmazione all'interno di una singola applicazione, ad esempio, in Java:

try (Context context = Context.create()) {
    Value function = context.eval("python", "lambda x: x + 1");
    assert function.canExecute();
    int x = function.execute(41).asInt();
    assert x == 42;
}

In questo snippet di codice stiamo creando una funzione definita in Python. Questa funzione non fa altro che incrementare di un'unità un valore per poi ritornarlo allo sviluppatore. Da Java, per sicurezza, chiediamo prima se la variabile function può eseguire attraverso la funzione canExecute(), per poi invocarla attraverso la funzione execute().[70]

Diffusione modifica

GraalVM è adottato in vari scenari industriali, tra i quali:

  • Disney: utilizza la native-image per ridurre i tempi di cold-start di alcuni suoi servizi su AWS[71]
  • Facebook: utilizzato per accelerare applicativi di Apache Spark riducendo l'impatto sulla memoria e sull'utilizzo della CPU[72]
  • Twitter: utilizzato per velocizzare alcuni micro-servizi della piattaforma[73]
  • Goldman Sach: la multinazionale di investimenti bancari ha riscritto il suo linguaggio di programmazione Slang basandolo su GraalVM attraverso Truffle.[74]

Note modifica

  1. ^ (EN) For Building Programs That Run Faster Anywhere: Oracle GraalVM Enterprise Edition, su blogs.oracle.com, Oracle Corporation. URL consultato il 4 luglio 2023.
  2. ^ a b c (EN) Alina Yurenko, A New GraalVM Release and New Free License!, su graalvm, 20 giugno 2023. URL consultato il 5 luglio 2023.
  3. ^ a b c d (EN) Why GraalVM?, su graalvm.org. URL consultato il 4 luglio 2023.
  4. ^ (EN) Christian Wimmer, Michael Haupt e Michael L. Van De Vanter, Maxine: An approachable virtual machine for, and in, java, in ACM Transactions on Architecture and Code Optimization, vol. 9, n. 4, 20 gennaio 2013, pp. 30:1–30:24, DOI:10.1145/2400682.2400689. URL consultato il 4 luglio 2023.
  5. ^ (EN) "Meta-Circularity is Near", GraalVM, Truffle--airhacks.fm podcast : Adam Bien's Weblog, su web.archive.org, 29 maggio 2020. URL consultato il 4 luglio 2023 (archiviato dall'url originale il 29 maggio 2020).
  6. ^ (FR) Graal : Un compilateur dynamique pour Java - Le Monde Informatique, su LeMondeInformatique, 13 febbraio 2012. URL consultato il 4 luglio 2023.
  7. ^ a b (EN) Revolutionizing Java with GraalVM Native Image, su InfoQ. URL consultato il 4 luglio 2023.
  8. ^ (EN) Oracle Database Multilingual Engine (MLE): GraalVM in the Database, su graalvm.org. URL consultato il 6 luglio 2023.
  9. ^ (EN) OpenJDK Announcement, su graalvm.org. URL consultato il 6 luglio 2023.
  10. ^ a b (EN) Node.js Runtime, su graalvm.org. URL consultato il 6 luglio 2023.
  11. ^ (EN) Philip K. Han, The State of GraalVM Native Image for Mobile Development, in Medium, 2 dicembre 2022. URL consultato il 6 luglio 2023.
  12. ^ a b c d (EN) Polyglot Programming, su web.archive.org, 23 ottobre 2020. URL consultato il 4 luglio 2023 (archiviato dall'url originale il 23 ottobre 2020).
  13. ^ a b (EN) Tools Reference, su web.archive.org, 25 aprile 2019. URL consultato il 4 luglio 2023 (archiviato dall'url originale il 25 aprile 2019).
  14. ^ a b (EN) OpenJDK: Graal, su openjdk.org. URL consultato il 4 luglio 2023.
  15. ^ (EN) [JDK-8255616] Removal of experimental features AOT and Graal JIT - Java Bug System, su bugs.openjdk.org. URL consultato il 4 luglio 2023.
  16. ^ (EN) Oleg Šelajev, Announcing GraalVM 19.3 with JDK 11 Support, su graalvm, 20 novembre 2019. URL consultato il 4 luglio 2023.
  17. ^ (EN) Oracle Technology Network License Agreement GraalVM Enterprise Edition Including License for Early Adopter Versions, su oracle.com.
  18. ^ (EN) Native Image: GraalVM Enterprise Edition vs. GraalVM Community Edition (PDF), su oracle.com.
  19. ^ (EN) GraalVM Community Release Calendar, su graalvm.org. URL consultato il 5 luglio 2023.
  20. ^ (EN) GraalVM Free Terms and Conditions (GFTC) including License for Early Adopter Versions, su oracle.com.
  21. ^ (EN) GraalVM for JDK 17, su graalvm.org. URL consultato il 5 luglio 2023.
  22. ^ (EN) GraalVM for JDK 20, su graalvm.org. URL consultato il 5 luglio 2023.
  23. ^ (EN) Release GraalVM Community Components 23.0.0 · graalvm/graalvm-ce-builds, su GitHub. URL consultato il 5 luglio 2023.
  24. ^ (EN) Open source Ideal Graph Visualizer · Issue #4998 · oracle/graal, su GitHub. URL consultato il 5 luglio 2023.
  25. ^ (EN) 22.3.2, su graalvm.org. URL consultato il 6 luglio 2023.
  26. ^ (EN) Alina Yurenko, GraalVM 22.3 is here: JDK 19 builds, jlink support, new monitoring features, and more!, su graalvm, 25 ottobre 2022. URL consultato il 5 luglio 2023.
  27. ^ (EN) Alina Yurenko, GraalVM 22.2: Smaller JDK size, improved memory usage, better library support, and more!, su graalvm, 19 agosto 2022. URL consultato il 5 luglio 2023.
  28. ^ (EN) 22.2.0, su graalvm.org. URL consultato il 6 luglio 2023.
  29. ^ (EN) Alina Yurenko, GraalVM 22.1: Developer experience improvements, Apple Silicon builds, and more, su graalvm, 27 aprile 2022. URL consultato il 5 luglio 2023.
  30. ^ (EN) GraalVM Release Notes 22.1.0, su graalvm.org, 26 aprile 2022. URL consultato il 26 aprile 2022.
  31. ^ (EN) GraalVM 22.0 is here!, su medium.com.
  32. ^ (EN) 22.0.0, su graalvm.org. URL consultato il 6 luglio 2023.
  33. ^ (EN) 21.2.0.1, su graalvm.org. URL consultato il 6 luglio 2023.
  34. ^ (EN) 21.1.0, su graalvm.org. URL consultato il 6 luglio 2023.
  35. ^ (EN) 21.0.0.2, su graalvm.org. URL consultato il 6 luglio 2023.
  36. ^ (EN) Oleg Šelajev, GraalVM 20.3 is available, su Medium, 20 novembre 2020. URL consultato il 31 dicembre 2020.
  37. ^ (EN) Oleg Šelajev, GraalVM 20.1, su graalvm, 19 maggio 2020. URL consultato il 6 luglio 2023.
  38. ^ (EN) A look at GraalVM 20.0: better Windows support, better Native Images, better tooling, su medium.com.
  39. ^ (EN) Oracle GraalVM Enterprise Edition 19 Documentation, su Oracle Help Center. URL consultato il 5 luglio 2023.
  40. ^ (EN) GraalVM LLVM Runtime, su graalvm.org. URL consultato il 6 luglio 2023.
  41. ^ a b (EN) GraalVM Native Image Support, su docs.spring.io. URL consultato il 4 luglio 2023.
  42. ^ a b (EN) Graal Compiler, su graalvm.org. URL consultato il 6 luglio 2023.
  43. ^ (EN) GraalVM - Graph Compilation, su graalvm.org.
  44. ^ a b (EN) Native Images, su web.archive.org, 20 aprile 2018. URL consultato il 4 luglio 2023 (archiviato dall'url originale il 20 aprile 2018).
  45. ^ (EN) GraalVM Open Source, su graalvm.org. URL consultato il 4 luglio 2023.
  46. ^ (EN) Ahead-of-Time (AOT) Compilation May Come to OpenJDK HotSpot in Java 9, su InfoQ. URL consultato il 4 luglio 2023.
  47. ^ (EN) [JDK-8166089] JEP 295: Ahead-of-Time Compilation - Java Bug System, su bugs.openjdk.org. URL consultato il 4 luglio 2023.
  48. ^ (EN) JEP 317: Experimental Java-Based JIT Compiler, su openjdk.org. URL consultato il 4 luglio 2023.
  49. ^ a b (EN) [JDK-8232118] Add JVM option to enable JVMCI compilers in product mode - Java Bug System, su bugs.openjdk.org. URL consultato il 4 luglio 2023.
  50. ^ a b (EN) Christian Wimmer e Thomas Würthinger, Truffle: a self-optimizing runtime system, in Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity, Association for Computing Machinery, 19 ottobre 2012, pp. 13–14, DOI:10.1145/2384716.2384723. URL consultato il 5 luglio 2023.
  51. ^ (EN) Blog | JRebel & XRebel by Perforce, su jrebel.com. URL consultato il 4 luglio 2023.
  52. ^ (EN) Truffle: Languages and Material, su Gist. URL consultato il 4 luglio 2023.
  53. ^ (EN) oracle/graal, Oracle, 4 luglio 2023. URL consultato il 4 luglio 2023.
  54. ^ (EN) Michael Van De Vanter, Chris Seaton e Michael Haupt, Fast, Flexible, Polyglot Instrumentation Support for Debuggers and other Tools, in The Art, Science, and Engineering of Programming, vol. 2, n. 3, 29 marzo 2018, DOI:10.22152/programming-journal.org/2018/2/14. URL consultato il 5 luglio 2023.
  55. ^ (EN) Getting Started with Instruments in GraalVM, su graalvm.org. URL consultato il 5 luglio 2023.
  56. ^ a b (EN) Chrome DevTools, su Chrome Developers. URL consultato il 5 luglio 2023.
  57. ^ (EN) oracle/graaljs, Oracle, 3 luglio 2023. URL consultato il 5 luglio 2023.
  58. ^ (EN) oracle/truffleruby, Oracle, 5 luglio 2023. URL consultato il 5 luglio 2023.
  59. ^ (EN) oracle/fastr, Oracle, 21 giugno 2023. URL consultato il 5 luglio 2023.
  60. ^ (EN) GraalPy, the GraalVM Implementation of Python, Oracle, 3 luglio 2023. URL consultato il 5 luglio 2023.
  61. ^ (EN) graal/sulong at master · oracle/graal, su GitHub. URL consultato il 5 luglio 2023.
  62. ^ (EN) graal/wasm at master · oracle/graal, su GitHub. URL consultato il 5 luglio 2023.
  63. ^ (EN) grCUDA: Polyglot GPU Access in GraalVM, NVIDIA Corporation, 26 giugno 2023. URL consultato il 5 luglio 2023.
  64. ^ (EN) GrCUDA: Polyglot GPU Access in GraalVM, NECSTLab, 14 maggio 2023. URL consultato il 5 luglio 2023.
  65. ^ (EN) Alberto Parravicini, Arnaud Delamare e Marco Arnaboldi, DAG-based Scheduling with Resource Sharing for Multi-task Applications in a Polyglot GPU Runtime, in 2021 IEEE International Parallel and Distributed Processing Symposium (IPDPS), 2021-05, pp. 111–120, DOI:10.1109/IPDPS49936.2021.00020. URL consultato il 5 luglio 2023.
  66. ^ (EN) Stefan Marr, SOMns - A Simple Newspeak Implementation, 20 febbraio 2023. URL consultato il 5 luglio 2023.
  67. ^ (EN) hpi-swa/trufflesqueak, Software Architecture Group, 20 giugno 2023. URL consultato il 5 luglio 2023.
  68. ^ (EN) Fabio Niephaus, Tim Felgentreff e Robert Hirschfeld, GraalSqueak: toward a smalltalk-based tooling platform for polyglot programming, in Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes, Association for Computing Machinery, 21 ottobre 2019, pp. 14–26, DOI:10.1145/3357390.3361024. URL consultato il 4 luglio 2023.
  69. ^ (EN) Yona Language - Yona Language, su yona-lang.org. URL consultato il 5 luglio 2023.
  70. ^ (EN) Embedding Languages, su graalvm.org. URL consultato il 5 luglio 2023.
  71. ^ (EN) Improving Developer Productivity at Disney with Serverless and Open Source | AWS Open Source Blog, su aws.amazon.com, 9 novembre 2022. URL consultato il 5 luglio 2023.
  72. ^ (EN) GraalVM at Facebook, su medium.com.
  73. ^ (EN) How Oracle GraalVM Supercharged Twitter’s Microservices Platform (PDF), su oracle.com.
  74. ^ (EN) One VM to Rule Them All? Lessons Learned with GraalVM | Curry On London! 2019, su curry-on.org. URL consultato il 5 luglio 2023.

Voci correlate modifica

Altri progetti modifica

Collegamenti esterni modifica

  Portale Informatica: accedi alle voci di Wikipedia che trattano di informatica
Estratto da "https://it.wikipedia.org/w/index.php?title=GraalVM&oldid=136271083"