Everything you need to know about GraalVM Native Image
0 likes228 views
GraalVM Native Image allows compiling Java programs into standalone native executables. It performs static analysis to identify all reachable code from the entry point. This results in instant startup times, low memory footprints, and is well-suited for cloud deployments. Native Image builds applications ahead-of-time during the build process, resulting in optimized machine code and no just-in-time compilation overhead at runtime. Reflection must be configured explicitly. Native Images provide benefits such as reduced memory usage compared to the JVM and increased security due to the static nature of the compiled application.
![Static native images
• statically linked against musl-libc , which can be used
without any additional library dependencies
• great for deploying on slim or distroless container images
FROM gcr.io/distroless/base
COPY build/native-image/application app
ENTRYPOINT ["/app"]
Mostly static native images
• statically link against all libraries except libc
• great for deploying such native images on distroless
container images
Static and Mostly Static Images
28](https://image.slidesharecdn.com/everythingcapetown-231026171606-7eab1d2f/85/Everything-you-need-to-know-about-GraalVM-Native-Image-28-320.jpg)
Everything you need to know about GraalVM Native Image
- 1. Alina Yurenko Developer Advocate for GraalVM Oracle Labs Cape Town Java Community Everything you need to know about GraalVM Native Image Photo by Andrea Brataas on Unsplash
- 2. • Alina Yurenko / @alina_yurenko • Developer Advocate for GraalVM at Oracle Labs • Love open source and communities 🤝 • Love both programming 👩💻 & natural languages 🗣 About me
- 3. 3 Ahead-of-Time (AOT) “Native Image” toolchain Language Runtimes High-performance optimizing compiler
- 4. native-image MyMainClass ./mymainclass JIT AOT java MyMainClass
- 5. native-image MyMainClass ./mymainclass JIT AOT java MyMainClass Clojure
- 6. Open source on GitHub: github.com/oracle/graal
- 8. GraalVM Native Image • Enables compiling Java programs into standalone native executables • Performs static analysis to identify all code reachable from the entry point • Instant startup, low memory footprint, perfect for cloud deployments • Integrations with Java microservices frameworks
- 9. Native Image Build Process Ahead-of-Time Compilation Application Libraries JDK Substrate VM Points-to Analysis Run Initializations Heap Snapshotting Input: All classes from application, libraries, and VM Iterative analysis until fixed point is reached Code in Text Section Image Heap in Data Section Image Heap Writing Output: Native executable
- 10. AOT vs JIT: Startup Time JIT Load JVM executable Load classes from file system Verify bytecodes Start interpreting Run static initializers First tier compilation (C1) Gather profiling feedback Second tier compilation (GraalVM or C2) Finally run with best machine code AOT ▪ Load executable with prepared heap ▪ Immediately start with optimized machine code
- 11. AOT vs JIT: Memory Footprint JIT Loaded JVM executable Application data Loaded bytecodes Reflection meta-data Code cache Profiling data JIT compiler data structures AOT ▪ Loaded application executable ▪ Application data
- 12. Tips & Tricks 🛠 14 JIT AOT Application payload Dynamic Code Cache Metaspace Class Files VM Runtime and Compiler Garbage Collector Profiling Feedback Memory Scalability Application payload Application Machine Code Garbage Collector Application payload Application payload Application payload Application payload Application payload Compilation Data Structures Application payload Dynamic Code Cache Metaspace Class Files Profiling Feedback Compilation Data Structures Application payload Dynamic Code Cache Metaspace Class Files Profiling Feedback Compilation Data Structures Application payload Dynamic Code Cache Metaspace Class Files Profiling Feedback Compilation Data Structures Application payload Dynamic Code Cache Metaspace Class Files Profiling Feedback Compilation Data Structures Application payload Dynamic Code Cache Metaspace Class Files Profiling Feedback Compilation Data Structures shared duplicated per process
- 13. Example: horizontal scaling of microservices Java HotSpot VM • 4 VM instances = 4 times the memory Native Image • 4 VM instances = 2 times the memory • Image heap shared between processes • Machine code shared between processes Memory Usage in MB Quarkus Apache Tika ODT in a “tiny” configuration and with the serial GC (1 CPU core per process, -Xms32m -Xmx128m) – JDK 11 0 200 400 600 800 1000 1200 1 process 2 processes 3 processes 4 processes 1109.0562 842.6914 576.3267 309.9619 132.2417 107.793 83.3442 58.8955 Native Image EE HotSpot C2
- 14. Tips & Tricks 🛠
- 15. • Build, test and run Java applications as native executables • Out-of-the-box support for native JUnit 5 testing • testing Java code with JUnit 5 behaves in the same way in native execution as with the JVM • allows libraries in the JVM ecosystem to run their test suites via GraalVM Native Image <plugin> <groupId>org.graalvm.buildtools</groupId> <artifactId>native-maven-plugin</artifactId> </plugin> Native Build tools: Official Gradle and Maven Plugins 🏗
- 16. Demo: Testing Native Image appliсations 16
- 17. • @EnabledInNativeImage • used to signal that the annotated test class or test method is only enabled when executing within GraalVM native images • when applied at the class level, all test methods within that class will be enabled within a native image • @DisabledInNativeImage • used to signal that the annotated test class or test method is only disabled when executing within a GraalVM native image. GraalVM Native Image & JUnit
- 19. • GraalVM 🤝 Reflection! • Native Image tries to resolve the target elements through a static analysis that detects calls to the Reflection API • If the analysis can not automatically detect your use of reflection, you might need additional configuration • Trace reflection, JNI, resource usage on the JVM with the tracing agent: • Agent to record usage and produce configuration files for native images • java -agentlib:native-image-agent=config-output-dir=META- INF/native-image ... • Manual adjustment / addition might still be necessary • Many frameworks & libraries ship reflection config that will be automatically picked up GraalVM & Reflection? 19
- 20. GraalVM & Reflection: demo 20
- 21. What about reflection in 3rd-party libraries? graalvm.org/native-image/libraries-and-frameworks
- 22. Is there an easier way to handle reflection? Yes! 22
- 24. Optimizing performance of native image native-image --pgo-instrument Instrumented Binary native-image --pgo optimized binary 🚀 Profiles (.iprof) Relevant Workloads
- 25. AOT at the speed of JIT 🚀 Performance of Spring Petclinic with Oracle GraalVM Native Image, GraalVM CE Native Image, and GraalVM CE with C2 JIT. Benchmark details: https://medium.com/graalvm/graalvm-for-jdk-21-is-here-ee01177dd12d
- 26. AOT at the speed of JIT 🚀 Performance of Spring Petclinic with Oracle GraalVM Native Image, GraalVM CE Native Image, and GraalVM CE with C2 JIT. Benchmark details: https://medium.com/graalvm/graalvm-for-jdk-21-is-here-ee01177dd12d
- 27. Compressing native images with UPX * more aggressive compression algorithms can have runtime impact
- 28. Static native images • statically linked against musl-libc , which can be used without any additional library dependencies • great for deploying on slim or distroless container images FROM gcr.io/distroless/base COPY build/native-image/application app ENTRYPOINT ["/app"] Mostly static native images • statically link against all libraries except libc • great for deploying such native images on distroless container images Static and Mostly Static Images 28
- 29. Reduced Attack Surface 🛡 • No new unknown code can be loaded at run time • Only paths proven reachable by the application are included in the image • Reflection is disabled by default and needs an explicit include list • Deserialization only enabled for specified list of classes • Just-in-time compiler crashes, wrong compilations, or “JIT spraying” to create machine code gadgets are impossible
- 31. • GraalVM 🤝 Reflection! • Native Image tries to resolve the target elements through a static analysis that detects calls to the Reflection API • If the analysis can not automatically detect your use of reflection, you might need additional configuration • Trace reflection, JNI, resource usage on the JVM with the tracing agent • Manual adjustment / addition might still be necessary GraalVM & Reflection? 31
- 32. Required Build Time Step • Computational effort necessary at build time • Need a powerful machine with the same target architecture & OS • Use GraalVM with GitHub Actions: github.com/marketplace/actions/github-action-for-graalvm • Many larger apps can build with 2 GB of memory • Develop in JIT mode for fast development, only use AOT for final deployment • For best throughput, use profile-guided optimizations
- 33. What’s new in GraalVM
- 34. 34
- 35. 35
- 37. GraalVM Community roadmap on GitHub https://github.com/orgs/oracle/projects/6
- 39. Get started with GraalVM graalvm.org or sdk install java 21-graal
- 40. 40 Questions & let’s connect! GraalVM resources