GraalVM Bootcamp Series

This Bootcamp were made for Hispanophone JUGs.

This presentation cover most aspects about GraalVM technology, from know about first steps, start a new cloud native project and optimize native images for production environments.
The idea behind of was try to train to the communities giving them an holistic vision of java future technologies in spanish language.

Bootcamp was developed in multiple series and presented mainly in Peru JUG.
1. Chapter 1: Starting with GraalVM
- JVM vs GraalVM
- GraalVM architecture and ecosystem
- JIT & AOT compilations
- Java agent for custom build native configurations.
2. Chapter 2: Developing java cloud native application
- GraalVM from Java frameworks: SpringBoot demo
- Containerization options
- CI/CD with Github Actions
- Deploying into AWS Fargate and Azure Container App
3. Chapter 3: Optimizing native images for high scale environments.
- Optimizing Quarkus app
- PGO + G1 GC
- Size compression with UPX
- Performance benchmark: Throughtput & latency, rss & cpu consumption, size & storage.

Transcript

1. GraalVM Bootcamp Series @c_zela czelabueno/graalvm-bootcamp-series/
2. Carlos Zela Bueno Cloud Architect Senior software engineer Oracle Knowledge Champions Miembro de @PeruJUG @c_zela https://github.com/czelabueno https://www.linkedin.com/in/czelabueno https://www.threads.net/@c.zelabueno
3. Agenda Parte 1/3 - Iniciando con GraalVM • JVM vs GraalVM • Ecosistema de GraalVM (JVMCI, graal compiler, native image, truffle framework) • Capacidades GraalVM • Just-In-Time (JIT) - Compilador `graal` en el HotSpot JVM Codigo maquina optimizado • Ahead-Of-Time (AOT) - Native Image Generar una imagen nativa desde: native-image Hello (.class) native-image --module-path Hello.jar --module HelloModule native-image -jar Hello.jar (.jar) Build tool: Maven y Gradle Perfiles con Maven `mvn clean package -Pnative` Tracing agent para generar archivos de configuracion automaticamente. Uso de `reflections` en tu aplicacion @c_zela
4. Ecosistema Java @c_zela
5. Confianza Modelo de desarrollo abierto y transparente. Comunidad global de desarrolladores de Java que se ayudan mutuamente a tener éxito. Innovación Innovación continua para satisfacer las necesidades actuales mientras se construye para el futuro. Previsibilidad Enfoque implacable en la productividad del desarrollador, la seguridad y la estabilidad de la plataforma, la disponibilidad oportuna de nuevos lanzamientos. 10M Desarrolladores java a full-time2 Nuestro mundo. Movido por Java. 75% usan Java para el desarrollo nativo en la nube2 60B JVMs activas globalmente en el 20211 #1 lenguaje para las tendencias tecnológicas actuales1 #1 lenguaje para iniciativas de seguridad1 #1 lenguaje para desarrollo nativo en la nube1 38B JVMs basadas en cloud en el 20211 29 Años desde su lanzamiento @c_zela Fuente: Oracle
6. ü Autor principal y colaborador de la tecnología Java. ü Patrocinador líder y administrador del ecosistema de Java. ü Impulsor líder de la innovación de plataformas. Contribuidores de JDK @c_zela
7. ü Invertir en innovación a largo plazo. ü Entrega un rico portafolio de nuevas características. ü Mantenga una "sensación de Java" mientras aborda nuevos desafíos y oportunidades. openjdk.org Amber Mejora continuamente la productividad del desarrollador a través de la evolución del lenguaje Java. Panama Alto rendimiento con una creación más sencilla de aplicaciones intensivas de E/S a través de cambios en la plataforma nativa de Java. Valhalla Mayor densidad de memoria, mejor rendimiento de ML y aplicaciones de big data a través de la introducción de tipos de valor. Loom Escale de forma masiva subprocesos ligeros, lo que vuelve a simplificar la simultaneidad. ZGC Cree un recolector de basura escalable de baja latencia capaz de manejar grandes heaps. Java en innovación continua @c_zela Fuente: Oracle
8. Java Virtual Machine @c_zela
9. HotSpot Más detalles sobre C1 y C2: https://www.beyondjava.net/graalvm-dictionary-bytecode-c1-c2-compiler • JVM • Agregado desde Java SE 1.3 (1999) • Desarrollado en C++ • Incluye 2 compiladores JIT: • C1: Client compiler • Inicio rápido • Menos énfasis en la optimización de código. • C2: Server compiler • Inicio ligeramente más lento. • Alta optimización de código. @c_zela
10. Arquitectura de la JVM How works: https://blog.hubspot.com/website/java-virtual-machine @c_zela
11. En ejecución @c_zela How works: https://blog.hubspot.com/website/java-virtual-machine
12. GraalVM & Graal @c_zela
13. @c_zela
14. @c_zela
15. High-performance optimizing Just- in-Time (JIT) compiler Ahead-of-Time (AOT) “Native Image” generator Multi-language support for the JVM ¿Qué es GraalVM? Es una nueva maquina virtual universal de alto rendimiento que proporciona mejoras significativas en la velocidad y la eficiencia de las aplicaciones. @c_zela Fuente: Oracle
16. Research: Oracle labs y colaboradores academicos https://graalvm.org/community/publications https://www.researchgate.net/publication/320359502_Making_collection_operations_optimal_with_aggressive_JIT_compilation Collection Operations Optimal with Aggressive JIT Compilation TruffleTaint: Polyglot Dynamic Taint Analysis on GraalVM 60+ papers científicos @c_zela
17. GraalVM team Fuente: http://lafo.ssw.uni-linz.ac.at/papers/2017_PLDI_GraalTutorial.pdf @c_zela
18. ¿Por qué GraalVM? • 1. High-performance modern Java • 2. Low-footprint, fast-startup Java • 3. Combine JavaScript, Java, Ruby, and R • 4. Run native languages on the JVM • 5. Tools that work across all languages • 6. Extend a JVM-based application • 7. Extend a native application • 8. Java code as a native library • 9. Polyglot in the database • 10. Create your own language Fuente: https://medium.com/graalvm/graalvm-ten-things-12d9111f307d @c_zela
19. Arquitectura de GraalVM Fuente: https://www.graalvm.org/22.3/docs/introduction/ JVMCI @c_zela
20. Ecosistema de GraalVM Fuente: https://www.graalvm.org/22.3/docs/introduction/ @c_zela
21. GraalVM != Graal @c_zela
22. graal compiler @c_zela
23. Truffle Fuente: https://lafo.ssw.uni-linz.ac.at/pub/papers/2016_PLDI_Truffle.pdf @c_zela
24. ¿Qué languajes admite GraalVM? Fuente: https://www.beyondjava.net/graalvm-polyglot-programming @c_zela
25. Polyglota Native image Static Analysis and Ahead-of-Time Compilation using Graal Fuente: https://lafo.ssw.uni-linz.ac.at/pub/papers/2016_PLDI_Truffle.pdf @c_zela
26. JIT vs AOT @c_zela
27. GraalVM Enterprise JIT Compiler—Ideal for traditional Java workloads Tomcat @c_zela Fuente: Oracle
28. Example: Java & R used from JavaScript / node.js Multiple languages in the same application const express = require('express') const app = express() const BigInteger = Java.type('java.math.BigInteger') app.get('/', function (req, res) { var text = 'Hello World from Graal.js!<br> ‘ // Using Java standard library classes text += BigInteger.valueOf(10).pow(100) .add(BigInteger.valueOf(1)).toString() + '<br>’ // Using R interoperability to create graphs text += Polyglot.eval(‘R’, ` svg(); require(lattice); x <- 1:100. y <- sin(x/10). z <- cos(x^1.3/(runif(1)*5+10)) print(cloud(x~y*z, main="cloud plot")) grDevices:::svg.off() `); res.send(text) }) app.listen(3000, function () { console.log('Example app listening on port 3000!') }) @c_zela Fuente: Oracle
29. Demo @c_zela
30. Configuraciones para dynamic features de Java • Using tracing agent: java -agentlib:native-image-agent=config-output-dir=./src/main/resources/META-INF/native- image -cp ./target/graalvmnidemos-1.0-SNAPSHOT-jar-with-dependencies.jar oracle.App • Tracing agent to generate the reflection configuration while you run your application. • First geneate reflection-config.json mvn clean package exec:exec -Pjava_agent • Second create native image mvn clean package -Pnative @c_zela
31. Agenda Parte 2/3 - Desarrollo de aplicaciones Java nativas de la nube • Frameworks: • Springboot (demo) • Micronaut • Quarkus • Helidon • Imagen nativa dentro de un contenedor docker. • Dynamic libs • Mostly static • Full static • GraalVM + Github actions • Despliegue en servicios Cloud • AWS, Azure, OCI @c_zela
32. Desarrollando Microservicios con: • Maven y Gradle • Spring AOT engine • Testing AOT usando -Dspring.aot.enabled=true • Incluye JUnit TestEngine • Build ni usando Buildpacks • Custom Hints usando @ImportRuntimeHints • Maven y Gradle • Build ni usando Docker • Micronaut @annotations para @TypeHint y @ReflectionConfig • Compatible con picocli • aot-jar.properties • aot-native-image.properties • Maven y Gradle • Soporte para aplicaciones Helidon SP y Helidon MP. • Java 17+ • Build ni usando docker • Maven y Gradle • Soporte con Mandrel or GraalVM • Build ni usando Docker y Podman. • Testing usando @NativeImageTest y @QuarkusIntegrationTest. • No requiere GraalVM (solo linux) • Graal config desde application.properties @c_zela
33. Soportado por java frameworks y plataformas cloud • Popular frameworks such as Spring Boot, Micronaut, Helidon, and Quarkus provide first-class support for GraalVM. • SDKs from leading cloud platforms such as AWS, Microsoft Azure, GCP, and Oracle Cloud Infrastructure integrate and support GraalVM. @c_zela Source code: https://github.com/czelabueno/graalvm-bootcamp-series/tree/pgo-g1/Serie2-DevelopingCloudJavaApp
34. Demo @c_zela
35. Ejecutables + OS c-libs Fuente: https://github.com/graalvm/graalvm-demos/blob/master/tiny-java-containers/ @c_zela
36. + Native Image Opciones de contenerizacion @c_zela Fuente: Oracle
37. • Slim: a paired down version of the full image generally with only the minimal packages needed to run your application—glibc • Distroless:similar to slim but no contain package managers, shells or any other programs —glibc • Alpine: image based on Alpine Linux with a complete package index and only 5 MB in size—musl • Scratch: for super minimal images that contain only a single binary and whatever it requires—no libc Lightweight Base Image Alternatives @c_zela Fuente: Oracle
38. Native Image dynamic linking Default Dynamic Linking -H:+StaticExecutableWithDynamicLibC --static --libc=musl Linked Libraries $ ldd hello $ ldd hello.mostlystatic $ ldd hello.static virtual ELF dynamic shared object linux-vdso.so.1 linux-vdso.so.1 not a dynamic executable Dynamic Linking libdl.so.2 libdl.so.2 POSIX threading libpthread.so.0 libpthread.so.0 POSIX real time extention librt.so.1 librt.so.1 Standard C library libc.so.6 libc.so.6 Dynamic Linker /lib64/ld-linux-x86-64.so.2 /lib64/ld-linux-x86-64.so.2 GCC low level routines libgcc_s.so.1 Math libm.so.6 Compression libz.so.1 Image Type Slim ✓ ✓ ✓ Distroless ✓ ✓ ✓ Alpine ✕ (musl-based) ✕ (musl dynamic linking not support) ✓ Scratch ✕ (no libc) ✕ (no libc) ✓ @c_zela Fuente: Oracle
39. Demo @c_zela
40. Containerization options • JDK17 FROM container-registry.oracle.com/java/openjdk:17-oraclelinux8 • Linux-slim (native executable) FROM container-registry.oracle.com/os/oraclelinux:8-slim mvn package -Pnative • Distroless (mostly static native executable) FROM gcr.io/distroless/base we pass a parameter, -H:+StaticExecutableWithDynamicLibC mvn package –Pdistroless • Scratch y/o Alpine ( full static native executable) native-image --static --libc=musl @c_zela
41. Devoxx Belgium 2022 - A 1.5MB Java Container App? Yes you can! Fuente: https://github.com/graalvm/graalvm-demos/blob/master/tiny-java-containers/ @c_zela
42. Agenda Parte 3/3 - Optimizando mi imagen nativa para entornos de alto rendimiento. • Frameworks: • Quarkus (demo) • Optimizando el rendimiento • Profiled Guide Optimization (PGO) • Gargabe Collector G1 • Modo rápido para “builds” durante el desarrollo –Ob • Compresion extrema con UPX • Benchmarking throughput / consumption • Jit vs PGO+G1 vs PGO+G1+UPX @c_zela
43. JIT vs AOT (native image) Caracteristicas de performance Startup Speed Peak Throughput Low Memory Footprint Reduced Max Latency Small Packaging Ahead-of-time Just-in-time @c_zela Fuente: Oracle
44. JDK vs GraalVM JIT vs GraalVM AOT Throughput 0 2000 4000 6000 8000 10000 12000 14000 16000 18000 20000 1,000 10,000 100,000 1,000,000 10,000,000 Requests per Second Cumulative number of requests sent by ApacheBench Popular Framework Benchmark GraalVM Enterprise Native Image GraalVM Enterprise JIT JDK12, HotSpot 16% higher 1500% higher @c_zela Fuente: Oracle
45. JDK vs GraalVM JIT vs GraalVM AOT Throughput 0 2000 4000 6000 8000 10000 12000 14000 16000 18000 20000 1,000 10,000 100,000 1,000,000 10,000,000 Requests per Second Cumulative number of requests sent by ApacheBench Popular Framework Benchmark GraalVM Enterprise Native Image GraalVM Enterprise JIT JDK12, HotSpot 16% higher 1500% higher @c_zela Fuente: Oracle
46. Optimizaciones AOT • Peak throughput • G1GC: Use the G1 GC ('--gc=G1’) • Use Profile-Guided Optimizations ('--pgo’) • CPU-Performance • Enable more CPU features with '-march=native’ • Memory • HEAP: Set max heap for improved and more predictable memory usage. • Build time • Use the quick build mode ('-Ob’) • Executable size • Compression using Ultimate Packer for eXecutables (UPX) @c_zela
47. Demo @c_zela
48. Active Garbage Collector java -XX:+UseSerialGC java -XX:+UseParallelGC java -XX:+UseG1GC java -XX:+UseEpsilonGC java -XX:+UseZGC java -XX:+UseShenanodoahC java -XX:+UseZGC -XX:+ZGenerational Garbage Collector Implementations Serial Simplest single thread Parallel Multiple threads G1 Multi-processor & large memory space Epsilon Passive GC isolated Shenandoah Ultra-low pause time GC ZGC Scalable Low latency Generational ZGC Split heap objects generations @c_zela
49. Active Garbage Collector java -XX:+UseSerialGC java -XX:+UseParallelGC java -XX:+UseG1GC java -XX:+UseEpsilonGC java -XX:+UseZGC java -XX:+UseShenanodoahC java -XX:+UseZGC -XX:+ZGenerational Garbage Collector Implementations Serial Simplest single thread Parallel Multiple threads G1 Multi-processor & large memory space Epsilon Passive GC isolated Shenandoah Ultra-low pause time GC ZGC Scalable Low latency Generational ZGC Split heap objects generations For JDK 17 For JDK 20 --gc=G1 --gc=epsilon @c_zela
50. Profile-Guided Optimizations (PGO) • Off: PGO is not used • instrument: The generated executable or shared library is instrumented to collect data for PGO (--pgo-instrument) • user-provided: PGO is enabled and uses a user-provided profile (for example -- pgo default.iprof) • ML-inferred: A machine learning (ML) model is used to infer profiles for control split branches statically. Source Code: https://github.com/oracle/graal/blob/master/docs/reference-manual/native-image/BuildOutput.md#recommendation-pgo @c_zela
51. JDK vs GraalVM JIT vs GraalVM AOT Throughput - Profile-Guided Optimizations (PGO) 0 2000 4000 6000 8000 10000 12000 14000 16000 18000 20000 1,000 10,000 100,000 1,000,000 10,000,000 Requests per Second Cumulative number of requests sent by ApacheBench Popular Framework Benchmark GraalVM Enterprise Native Image GraalVM Enterprise JIT JDK12, HotSpot Fuente: Oracle @c_zela
52. Startup Speed Peak Throughput Low Memory Footprint Reduced Max Latency Small Packaging Ahead-of-time Just-in-time JIT vs AOT Profile-Guided Optimizations (PGO) Fuente: Oracle @c_zela
53. Benchmarking Quarkus app con GraalVM for JDK 17 Source Code: https://github.com/czelabueno/graalvm-bootcamp-series/tree/pgo-g1/Serie3-OptimizingNativeImage/bench-histograms @c_zela GraalVM JIT GraalVM AOT PGO G1
54. Benchmarking Spring PetClinic con Java 20 Fuente: https://medium.com/graalvm/a-new-graalvm-release-and-new-free-license-4aab483692f5 @c_zela
55. El future de GraalVM GraalWasm – Una implementacion de WebAssembly Mayor velocidad en la construccion de imagenes nativas. Mas funciones con Machine Learning. Adopcion de mas implementaciones de GC. Adopcion mas rapida de Java GA features. Oracle GraalVM Container Images @c_zela
56. Gracias ! @c_zela @czelabueno Reproduce este Bootcamp czelabueno/graalvm-bootcamp-series/