GraalVM

GraalVM 23 (JDK 17 e 20)

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). Sono infatti disponibili due edizioni, GraalVM per JDK 17.0.7 e JDK 20.0.1. In questo periodo transitorio è comunque possibile riferirsi alla versione GraalVM 23.0.0. 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.

GraalVM 22

• GraalVM 22.3: Rilasciata nel ottobre 2022. Questa edizione include il supporto al JDK 19, in quanto nelle successive versioni di GraalVM, il supporto a JDK 11 verrà deprecato.
• GraalVM 22.2: Rilasciata nel luglio 2022. Con questa edizione il JDK GraalVM è diventato modulare per ridurre le dimensioni dello stesso. 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.
• 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. 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.
• 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. Inoltre è stata migliorata la descrizione a terminale del processo di creazione delle native-image.

GraalVM 21

• 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.
• 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.
• 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.

GraalVM 20

• 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.
• 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).
• 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.

GraalVM 19

• 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.

Compilatore GraalVM

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. 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:

• 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.

GraalVM Native Image

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.

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.

GraalVM Native Image è ufficialmente supportata dai framework Fn, Gluon, Helidon, Micronaut, Picocli, Quarkus, Vert.x e SpringBoot Java. 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. 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.

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

Piattaforma di implementazione linguaggi Truffle

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

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.

Supporto a strumenti di misurazione

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.

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. GraalVM include inoltre un'implementazione del backend del protocollo di debugging remoto di Chrome Inspector. Anche se originariamente ideato per debugging di codice JavaScript, può essere utilizzato per debuggare tutti i linguaggi di GraalVM direttamente dal proprio browser.

Creazione di array

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:

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

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().