Book Image

Supercharge Your Applications with GraalVM

By : A B Vijay Kumar
Book Image

Supercharge Your Applications with GraalVM

By: A B Vijay Kumar

Overview of this book

GraalVM is a universal virtual machine that allows programmers to compile and run applications written in both JVM and non-JVM languages. It improves the performance and efficiency of applications, making it an ideal companion for cloud-native or microservices-based applications. This book is a hands-on guide, with step-by-step instructions on how to work with GraalVM. Starting with a quick introduction to the GraalVM architecture and how things work under the hood, you'll discover the performance benefits of running your Java applications on GraalVM. You'll then learn how to create native images and understand how AOT (ahead-of-time) can improve application performance significantly. The book covers examples of building polyglot applications that will help you explore the interoperability between languages running on the same VM. You'll also see how you can use the Truffle framework to implement any language of your choice to run optimally on GraalVM. By the end of this book, you'll not only have learned how GraalVM is beneficial in cloud-native and microservices development but also how to leverage its capabilities to create high-performing polyglot applications.

Related Content you might be interested in

Current Title:

Small book image
Supercharge Your Applications with GraalVM
A B Vijay Kumar
Aug, 2021 | 360 pages
Small book image
Mastering the Java Virtual Machine
Otàvio Santana
Feb, 2024 | 234 pages
Small book image
Practical WebAssembly
Sendil Kumar Nellaiyapen
May, 2022 | 232 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Code in Action
Download the color images
Conventions used
Get in touch
Reviews
1
Section 1: The Evolution of JVM
Section 1: The Evolution of JVM
Free Chapter
2
Chapter 1: Evolution of Java Virtual Machine
Chapter 1: Evolution of Java Virtual Machine
Technical requirements
Introduction to GraalVM
Learning how JVM works
Understanding the JVM architecture
Summary
Questions
Further reading
3
Chapter 2: JIT, HotSpot, and GraalJIT
Chapter 2: JIT, HotSpot, and GraalJIT
Technical requirements
Setup environment
Taking a deep dive into HotSpot and the C2 JIT compiler
Understanding the optimizations performed by JIT
Deoptimization
Graal JIT and the JVM Compiler Interface (JVMCI)
Summary
Questions
Further reading
4
Section 2: Getting Up and Running with GraalVM – Architecture and Implementation
Section 2: Getting Up and Running with GraalVM – Architecture and Implementation
5
Chapter 3: GraalVM Architecture
Chapter 3: GraalVM Architecture
Reviewing modern architectural requirements
Learning what the GraalVM architecture is
Reviewing the GraalVM editions (Community and Enterprise)
Understanding the GraalVM architecture
An overview of GraalVM microservices architecture
Understanding how GraalVM addresses various non-functional aspects
Summary
Questions
Further reading
6
Chapter 4: Graal Just-In-Time Compiler
Chapter 4: Graal Just-In-Time Compiler
Technical requirements
Setting up the environment
Understanding the Graal JIT compiler
Understanding Graal compiler optimizations
Debugging and monitoring applications
Summary
Questions
Further reading
7
Chapter 5: Graal Ahead-of-Time Compiler and Native Image
Chapter 5: Graal Ahead-of-Time Compiler and Native Image
Technical requirements
Building native images
Analyzing the native image with GraalVM Dashboard
Understanding PGO
Native image configuration
Generating Graal graphs for native images
Understanding how native images manage memory
Building static native images and native shared libraries
Debugging native images
Limitations of Graal AOT (Native Image)
GraalVM containers
Summary
Questions
Further reading
8
Section 3: Polyglot with Graal
Section 3: Polyglot with Graal
9
Chapter 6: Truffle for Multi-language (Polyglot) support
Chapter 6: Truffle for Multi-language (Polyglot) support
Exploring the Truffle language implementation framework
Exploring the Truffle interpreter/compiler pipeline
Learning Truffle DSL
Understanding how Truffle supports interoperability
Understanding Truffle instrumentation
Ahead-of-time compilation using Truffle
Optimizing Truffle interpreter performance with launcher options
SimpleLanguage and Simple Tool
Summary
Questions
Further reading
10
Chapter 7: GraalVM Polyglot – JavaScript and Node.js
Chapter 7: GraalVM Polyglot – JavaScript and Node.js
Technical requirements
Understanding the JavaScript (including Node.js) Truffle interpreter
Summary
Questions
Further reading
11
Chapter 8: GraalVM Polyglot – Java on Truffle, Python, and R
Chapter 8: GraalVM Polyglot – Java on Truffle, Python, and R
Technical requirements
Understanding Espresso (Java on Truffle)
Understanding GraalPython – the Python Truffle interpreter
Understanding FastR – the R Truffle interpreter
Summary
Questions
Further reading
12
Chapter 9: GraalVM Polyglot – LLVM, Ruby, and WASM
Chapter 9: GraalVM Polyglot – LLVM, Ruby, and WASM
Technical requirements
Understanding LLVM – the (Sulong) Truffle interface
Understanding TruffleRuby – the Ruby Truffle interpreter
Understanding GraalWasm – the WASM Truffle interpreter
Summary
Questions
Further reading
13
Section 4: Microservices with Graal
Section 4: Microservices with Graal
14
Chapter 10: Microservices Architecture with GraalVM
Chapter 10: Microservices Architecture with GraalVM
Technical requirements
Overview of microservices architecture
Building microservices architecture with GraalVM
Case study – online book library
Exploring modern microservices frameworks
Summary
Questions
Further reading
15
Assessments
Assessments
Chapter 1 – Evolution of Java Virtual Machine
Chapter 2 – JIT, Hotspot, and GraalJIT
Chapter 3 – Graal VM Architecture
Chapter 4 – Graal Just-In-Time Compiler
Chapter 5 – Graal Ahead-of-Time Compiler and Native Image
Chapter 6 – Truffle for Multi-language (Polyglot) support
Chapter 7 – GraalVM Polyglot – JavaScript and Node.js
Chapter 8 – GraalVM Polyglot – Java on Truffle, Python, and R
Chapter 9 – GraalVM Polyglot – LLVM, Ruby, and WASM
Chapter 10 – Microservices Architecture with GraalVM
Why subscribe?
16
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Leave a review - let other readers know what you think

What this book covers

Chapter 1, Evolution of Java Virtual Machine, walks through the evolution of JVM and how it optimized the interpreter and compiler. It will walk through C1 and C2 compilers, and the kind of code optimizations that JVM performs to run Java programs faster.

Chapter 2, JIT, HotSpot, and GraalJIT, takes a deep dive into how JIT compilers and Java HotSpot work and how JVM optimizes code at runtime.

Chapter 3, GraalVM Architecture, provides an architecture overview of Graal and the various architecture components. The chapter goes into details on how GraalVM works and how it provides a single VM for multiple language implementations. This chapter also covers the optimizations GraalVM brings on top of standard JVM.

Chapter 4, Graal Just-In-Time Compiler, talks about the JIT compilation option of GraalVM. It goes through the various optimizations the Graal JIT compiler performs in detail. This is followed by a hands-on tutorial to use various compiler options to optimize the execution.

Chapter 5, Graal Ahead-of-Time Compiler and Native Image, is a hands-on tutorial that walks through how to build native images and optimize and run these images with profile-guided optimization techniques.

Chapter 6, Truffle for Multi-language (Polyglot) support, introduces the Truffle polyglot interoperability capabilities and high-level framework components. It also covers how data can be transferred between applications that are written in different languages that are running on GraalVM.

Chapter 7, GraalVM Polyglot – JavaScript and Node.js, introduces the JavaScript and NodeJs. This is followed by a tutorial on how to use the Polyglot API for interoperability to interoperate between an example JavaScript and NodeJS application and a Python application.

Chapter 8, GraalVM Polyglot – Java on Truffle, Python, and R, introduces Python, R, and Java on Truffle (Espresso). This is followed by a tutorial on how to use the Polyglot API for interoperability between various languages.

Chapter 9, GraalVM Polyglot – LLVM, Ruby, and WASM, introduces JavaScript and Node.js. This is followed by a tutorial on how to use the Polyglot API to interoperate between an example JavaScript/Node.js applications.

Chapter 10, Microservices Architecture with GraalVM, covers the modern microservices architecture and how new frameworks such as Quarkus and Micronaut implement Graal for the most optimum microservices architecture.

Previous Section
Next Section