GraalVM: Uma nova JVM realçada para Cloud-Native

Published in

Troopers-Legacy

7 min readJan 3, 2024

Faaala galerinha, ocês tão baom?! Tomara que sim !!!

O papo hoje é sobre GraalVM! Uma nova Java Virtual Machine (JVM) que chegou balançando todo ecossistema da plataforma Java. Vamos explanar sobre a arquitetura e seus componentes, os ambientes de execução (Runtime Environments), as distribuições e os principais benefícios da GraalVM. #Let’s Booooora?!

O que é a GraalVM?

Em resumo, GraalVM é uma nova JVM focada para o novo (mas não tão novo) mundo da nuvem: Cloud-native e Serverless. Requisitos de aplicação, como inicialização mais rápida (Quicker bootstrap), baixo consumo de memória (Smaller Footprint) e desempenho (High-Performance), são princípios atendidos com maestria pela GraalVM.

Esta nova JVM surge através de um projeto de pesquisa da Oracle Labs. O objetivo principal era criar um motor totalmente multilinguagem e com desempenho competitivo na indústria de software do mercado. Para isso, iniciaram esforços para criar um compilador (Graal Compiler) que não possuísse conhecimento semântico da linguagem (refere-se a interpretação do código) já que o bytecode Java tinha muita semântica Java incorporada. Além do Graal Compiler, outros componentes importantes foram adicionados à nova VM: Truffle e Substrate VM. Vale lembrar que por ser uma distribuição baseada na HotSpot VM/OpenJDK, a GraalVM acaba trazendo todos os componentes já conhecidos na JVM. Em comparação com a HotSpot, os principais diferenciais da GraalVM são: Graal Compiler (JIT e IOT), Image-Native e Recursos poliglotas — framework para implementação de novas linguagens com seus interpretadores — , API de interoperabilidade entre linguagens e interpretador LLVM — para executar linguagens que são transformadas para LLVM IR bitcode.

Nas seções a seguir, falaremos mais sobre os principais componentes da GraalVM.

Arquitetura e Componentes

***Figura 1***— Arquitetura GraalVM. **Fonte**: Autor.

A arquitetura da GraalVM é formada por vários componentes. A imagem acima demonstra em uma visão macro a estrutura modularizada. Também é possível perceber que a estrutura provê uma plataforma multilinguagem — proposta principal do projeto GraalVM.

Adiante, vamos explorar brevemente alguns detalhes da arquitetura GraalVM.

Componentes Core e Adicionais

Existem componentes essenciais que podem ser adicionados a GraalVM. Esses componentes adicionais podem transformá-laem uma plataforma Runtime através de linguagens baseadas em JVM (Java, Kotlin, Scala, Groovy) e/ou implementadas em cima do Truffle — framework de implementação de linguagem na GraalVM, ambas permitindo interoperar (programação poliglota). Na seção Plataformas Runtime serão apresentados alguns exemplos de plataformas. Antes, vamos dar uma olhada nos principais componentes a seguir.

Core

Java HotSpot VM : Java HotSpot VM com Graal JIT compiler embutido.
Graal JIT: Compilador que substitui C2 da HotSpot VM. A implementação é baseada na JEP 243 ( JVM Compiler Interface).
Polyglot API: Combinação de linguagens de programação que compartilham valores uma com a outra em um ambiente de execução compartilhado. Isso se dá por meio do Truffle.

Adicionais

Native Image: É a tecnologia que utiliza a abordagem de compilação Ahead-of-time (AOT) para criar um executável de plataforma nativo binário. Ao fim do processo dessa técnica o executável nativo é construído na SubstrateVM — um VM com recursos necessários para rodar uma aplicação, como gerenciamento de memória, coletor de lixo, agendamento de thread, entre outras. Construção de aplicações por meio deste componente pode trazer benefícios como: velocidade no startup da aplicação e redução de custo.
LLVM Toolchain: Conjunto de ferramentas e APIs para compilar (como clang para C e C++ e rustc para Rust) e executar(lli para bitcode LLVM) programas nativos em bitcode LLVM IR que podem ser executados na GraalVM.
LLVM IR Interpreter (Sulong): É um motor de interpretação para executar bitcode LLVM IR. Compiladores de linguagens como C, C++, Rust, Swift, Object-C, Fortran e outras, são construídas em LLVM, que por sua vez fornece uma representação intermediária (LLVM-IR) que podem ser interpretadas pelo Sulong. A Figura 1 ilustra a utilização dos componentes LLVM Toolchain + Sulong.
Linguagem implementada com Truffle: Atualmente já existem várias implementações estáveis como JavaScript — Graal.Js, NodeJs — Graal.Nodejs, Regex — TRegex e algumas que estão em fase experimental(até data da escrita deste material): Python — GraalPy, Ruby — TruffleRuby, WebAssembly — Wasm, R —FastR , e Java on Truffle — Espresso.

***Figura 2***— Compilação e Execução de códigos transformados em bitcode LLVM IR na GraalVM. **Fonte**: Autor.

Obviamente existem outros componentes na arquitetura GraalVM, no entanto, decidimos mostrar os mais relevantes para esse estudo.

Principais Runtime Environments

Agora pare ! Pense … Já pensou em rodar um código JavaScript dentro de uma JVM? E um código C, C++, Swift ou até mesmo Python? E se quiséssemos trabalhar com todas elas em um único ambiente (programação poliglota)? Até já vimos algo um pouco “parecido” com isso, os projetos Jython e Nashorn. Mas, e se fosse sua linguagem preferida? E se fosse o “PHP da massa” 🤪? Todas essas suposições podem ser possíveis na GraalVM.

No lançamento da primeira versão do GraalVM, Thomas Wuerthinger, que na época era diretor de pesquisa do Oracle Labs, foi entrevistado pela InfoQ. Na ocasião, foi perguntado:

InfoQ: What are the key technologies that make up GraalVM? How will they help developers?
Wuerthinger: The key technology idea in GraalVM is called “Partial Evaluation”, which is a technique for converting interpreters into compilers automatically. This allows you to build new languages very quickly. Language developers can focus on just building an [Abstract Syntax Tree] AST interpreter, and do not have to worry about writing a code generator or other low-level runtime functionality like a garbage collector.

É uma proposta e tanto, poder implementar parcialmente uma linguagem de seu gosto para rodar dentro de uma plataforma que fornece inúmeros benefícios (Graal-JIT, Polyglot Programming, Cloud-native).

Ao passo que a GraalVM foi adicionando novas linguagens dentro do seu ambiente de execução por intermédio do Truffle, tornou-se possível ter um ambiente de execução (Runtime Environment) por essas linguagens. Também temos o LLVM, que pode ser um ambiente de execução para executar linguagens que são transformadas para LLVM IR bitcode.

Abaixo, segue alguns Runtime Environments disponíveis na GraalVM:

Java HotSpot VM
LLVM Runtime
JavaScript & Node.js Environment

*Todos Runtime Environments contém o component Graal Compiler 🥳🎉👏.

Das distribuições(EE & CE) e suas diferenças

A GraalVM está disponível nas versões Enterprise Edition (EE) e Community Edition (CE), baseada na Oracle JDK e na OpenJDK, respectivamente. Com relação a licença para uso, GraalVM EE tem restrições de uso de acordo com os termos e condições GFTC, enquanto GraalVM CE é distribuído sob GPLv2+CPE 🎉, porém, não há suporte comercial 🥲 (apenas pela comunidade). Ainda sobre as licenças, devemos considerar os termos e condições individuais para os componentes GraalVM, que podem ser específicas do projeto. Por exemplo o componente Sulong que está disponível sob uma licença 3-clause BSD.

Agora vamos às diferenças! Quando comparamos a distribuição EE com a CE, podemos destacar as vantagens da EE:

~20% mais eficiente em termos de desempenho (Graal JIT -Dgraal.CompilerConfiguration=enterprise);
~2% mais eficiente em termos de desempenho para as linguagens implementadas com Truffle, tais como: JavaScript, Python, R e Ruby;
Redução de ~2% no consumo de memória(Smaller Footprint);
Debugging tools (Ideal Graph Visualizer): Ajuda a debugar problemas e realizar ajustes finos para melhorar o desempenho da GraalVM;
GraalVM LLVM IR interpreter (Managed): A versão Managed fornece um modo de execução gerenciado para evitar falhas e travamentos do programa, principalmente em linguagens como C/C++;
Profile Guided Optimization (PGO): Técnica utilizada para otimizar códigos em executáveis nativos;
G1GC: Garbage Collector, um coletor de lixo multi-thread para um aumentar o desempenho. Recomendo fortemente a leitura desse material JEP-248;
Suporte comercial Oracle.

Embora não disponha das vantagens mencionadas acima, a GraalVM CE ainda é uma excelente escolha, especialmente quando comparada à Java HotSpot VM/OpenJDK.

Benefícios

Abaixo estão listados os principais benefícios da GraalVM encontrados pelo estudo.

Alto desempenho com Graal JIT: Aplicações construídas em Java e linguagens implementadas com o Truffle podem tirar proveito do compilador Graal JIT, que implementa várias técnicas de otimização de código em tempo de execução (JIT) melhorando desempenho para aplicação;
Baixo consumo de recursos: Com a abordagem de compilação nativa, aplicações demandam de menos recursos computacionais, como Memória e CPU, que resulta na redução de custo;
Inicialização rápida: A inicialização mais rápida da aplicação (Quicker bootstrap) é um requisito atendido pela GraalVM. Ao pensar em computação em nuvem, especialmente no modelo Serverless, é essencial que a aplicação tenha o menor tempo possível de inicialização;
Interoperabilidade e Incorporabilidade: A interoperabilidade refere-se à expertise de permitir chamadas de código entre linguagens diferentes. Já a incorporabilidade permite a integração de código de linguagens diferentes no mesmo programa. Ambas são pontos fundamentais para a programação poliglota, uma das principais propostas da GraalVM.

Para descobrir mais benefícios, acesse a página 'Por que GraalVM?' no site oficial do projeto GraalVM.

Considerações finais

Diante de um cenário em que as aplicações precisam atender algumas exigências para combinar bem ao mundo da Cloud Native e Serverless, a GraalVM contém todos os apetrechos necessários para construir aplicações que atendem os requisitos, como alto desempenho, baixo consumo de recursos computacionais e ambiente multilinguagem. Além disso, fornece ferramentas para desenvolvimento, como ajustes finos de desempenho nas aplicações, debugging e monitoramento (conjunto de instrumentos para depurar e monitorar aplicações). Tudo isso em uma única plataforma! 😁