You're reading from Supercharge Your Applications with GraalVM Hands-on examples to optimize and extend your code using GraalVM's high performance and polyglot capabilities

Product type Paperback

Published in Aug 2021

Publisher Packt

ISBN-13 9781800564909

Length 360 pages

Edition 1st Edition

Languages

Java

Tools

LLVM

Concepts

High Performance Programming

Author (1):

A B Vijay Kumar

Preface

1. Section 1: The Evolution of JVM

2. Chapter 1: Evolution of Java Virtual Machine FREE CHAPTER

3. Chapter 2: JIT, HotSpot, and GraalJIT

4. Section 2: Getting Up and Running with GraalVM – Architecture and Implementation

5. Chapter 3: GraalVM Architecture

6. Chapter 4: Graal Just-In-Time Compiler

7. Chapter 5: Graal Ahead-of-Time Compiler and Native Image

8. Section 3: Polyglot with Graal

9. Chapter 6: Truffle for Multi-language (Polyglot) support

10. Chapter 7: GraalVM Polyglot – JavaScript and Node.js

11. Chapter 8: GraalVM Polyglot – Java on Truffle, Python, and R

12. Chapter 9: GraalVM Polyglot – LLVM, Ruby, and WASM

13. Section 4: Microservices with Graal

14. Chapter 10: Microservices Architecture with GraalVM

15. Assessments

16. Other Books You May Enjoy

Chapter 4 – Graal Just-In-Time Compiler

Graal JIT compilation can be divided into two phases: frontend and backend.
The frontend phase is platform-independent compilation, where the code is converted to a platform-independent intermediate representation called High-Level Intermediate Representation (HIR), represented via Graal Graphs. This HIR is optimized in three tiers: High, Medium, and Low.
The backend phase is more platform-dependent compilation, where a Low-Level Intermediate Representation (LIR) is created and optimized at the machine code level. These optimizations are platform dependent.
Refer to the Graal JIT compilation pipeline and Tiered Optimization section for more details.
Intermediate Representations (IRs) are among the most important data structures for compiler design. IRs provide a graph that helps the compiler understand the structure of the code, identify opportunities, and perform optimizations. Refer to the Graal Intermediate Representation section...

The rest of the chapter is locked