Smalltalk JIT Compilation: LLVM Experimentation

Smalltalk JIT
Compilation
LLVM Experimentation
Janat Baig (Presenter) & Dave Mason

Contents
1. Intro to JIT Compilers
2. Intro to LLVM
3. Textual LLVM IR
4. Emitting Textual LLVM IR
a. Flow Analysis
b. Example Walkthrough
5. Future Work

Intro to JIT Compilers
- There are two main implementation
techniques: Compilation and
Interpretation
- Compilers produce code to be executed
by hardware - typically ahead of time
- Interpreters do this execution in software
- Just In Time (JIT) is a technique that can
improve performance for interpreters by
compiling to more efficient code
dynamically at runtime
- JIT compiler generated code is typically
10x faster than interpretation
Basic Example
1. Method X is invoked multiple
times
2. JIT labels method X as a
hotspot
3. Compiles method X + applies
optimizations from runtime
information
4. Beneﬁt? Don’t have to scan,
parse and interpreter method
X every time it is invoked

JIT Compilers In Use
Used in lots of systems!

Intro to LLVM
- LLVM is a toolset for building compilers
- Can generate machine code for a plethora of architectures through the
LLVM compiler (LLC)
- LLC also performs a multitude of optimizations on it’s IR
- LLVM intermediate representation (IR) is a register-based form that uses
Single Static Assignment (SSA)

x = 1;
x = x + 1
x1 = 1;
x2 = x1 + 1
Since the LLVM IR uses SSA form,
we need to ensure that we adhere
to its restrictions:
1. Unique assignment #s
2. Phi Node at converging
paths

x = 1 x = 2
Block 1 Block 2
y = x(?) + 1
x1 = 1 x2 = 2
x3 = phi(x1, x2)
y = x3 + 1
Block 1 Block 2
Since the LLVM IR uses SSA form,
we need to ensure that we adhere
to its restrictions:
1. Unique assignment #s
2. Phi Node at converging
paths

Textual LLVM IR
LLVM has an binary API and a textual form.
Why are we experimenting with emitting textual IR?
1. Textual IR is easy to verify by eye
2. Debugging textual IR is simpler
3. Advantage of LLVM tooling for textual IR

Overall Compile Strategy
● convert AST to intermediate form
○ compile-time stack mimics run-time stack
○ sequence of basic blocks ending in send or return
● (optional) inlining
○ replaces some sends with embedded operations
○ target blocks become inline blocks
● for LLVM target
○ do ﬂow analysis for SSA within ReturnBlocks
■ all values live in registers within ReturnBlocks
■ between ReturnBlocks only the stack/context is persistent

Source Code Zag AST Basic Blocks
Textual
LLVM IR
Steps to Emit LLVM IR
Inlining+Data
Flow Analysis

Generating Zag AST
Source Code Pharo AST
Example 1, 1st Stage (Pharo hosted)

Pharo AST Zag AST
Generating the Zag AST (Cont.)
Example 1, 2nd Stage (Pharo hosted)

Zag AST Basic Blocks
Generating Basic Blocks
Example 1, 3rd Stage

Inlining +
Flow
Analysis
Flow Analysis
Example 1, 4th Stage
Basic Blocks
Data ﬂow analysis
- On Demand: on the stack already (self
parameters, read-only unless locals or
temps)
- New: Not on stack, only spilled to stack
when a call is invoked
- Phi: special case when the value came
from 2 different paths (none in this ex.)
Sample Stack

Generating Textual LLVM IR
define ptr @plus_and_and_(ptr noundef %.pc, ptr noundef %.sp, ptr noundef %.process, ptr
noundef %.context, i64 %.signature) #1 {
** push values and setup for send **
%30 = musttail call ptr %29(i64 %28, ptr nonnull align 8 %.sp.1, ptr nonnull align 8
%.process, ptr nonnull align 8 %.context.1, i64 %27)
ret ptr %30}
define ptr @plus_and_and_.1(ptr noundef %.pc, ptr noundef %.sp, ptr noundef %.process,
ptr noundef %.context, i64 %.signature) #1 {
** reset for next send **
%3 = musttail call ptr %2(i64 %1, ptr nonnull align 8 %.sp, ptr nonnull align 8
%.process, ptr nonnull align 8 %.context, i64 %4)
ret ptr %3}
define ptr @plus_and_and_.2(ptr noundef %.pc, ptr noundef %.sp, ptr noundef %.process,
ptr noundef %.context, i64 %.signature) #1 {
** setup for return **
%5 = musttail call ptr %2(i64 %3, ptr nonnull align 8 %.sp, ptr nonnull align 8
%.process, ptr nonnull align 8 %.context, i64 undef)
ret ptr %5}
Basic Blocks

Basic Blocks
Initial Stack
Before Send
define ptr @plus_and_and_(ptr noundef %.pc, ptr noundef %.sp, ptr noundef %.process, ptr noundef %.context, i64
%.signature) #1 {
%17 = getelementptr inbounds %zag.execute.Stack, ptr %.sp, i64 0, i32 2
%n1 = load i64, ptr %17, align 8 ; n1
%19 = getelementptr inbounds %zag.execute.Stack, ptr %.sp, i64 0, i32 1
%n2 = load i64, ptr %19, align 8 ; n2
%n3 = load i64, ptr %.sp, align 8 ; n3
; ** create context pointed by %.context.1 **
; make space to spill to memory
%.sp.1 = getelementptr inbounds %zag.execute.Stack, ptr %context.1, i64 0, i32 -3
%22 = getelementptr inbounds %zag.execute.Stack, ptr %.sp.1, i64 0, i32 2
store i64 %n1, ptr %22, align 8 ; n1 in reserved space
%23 = getelementptr inbounds %zag.execute.Stack, ptr %.sp.1, i64 0, i32 1
store i64 %n2, ptr %23, align 8 ; n2 in reserved space
store i64 %n3, ptr %sp.1, align 8 ; n3 in reserved space
; ** get native return address (@plus_and_and_.1) into %24 **
%25 = getelementptr inbounds %zag.context.Code, ptr %.tpc, i64 0, i32 1 ; threaded return into %25
%26 = getelementptr inbounds %zag.context.Context, ptr %context.1, i64 0, i32 3
store ptr %24, ptr %26, align 8 ; native PC
%27 = getelementptr inbounds %zag.context.Context, ptr %context.1, i64 0, i32 2
store ptr %25, ptr %27, align 8 ; threaded PC
; ** set %28 to the dispatch send address **
; ** set %29 to the symbol value for #* **
%30 = musttail call ptr %28(ptr %25, ptr nonnull align 8 %.sp.1, ptr nonnull align 8 %.process, ptr nonnull align
8 %.context.1, i64 %29)
ret ptr %30}

Basic Blocks
define ptr @plus_and_and_.1(ptr noundef %.tpc, ptr noundef %.sp, ptr noundef
%.process, ptr noundef %.context, i64 %.signature) #1 {
; ** get native return address (@plus_and_and_.2) into %1 **
%2 = getelementptr inbounds %zag.context.Code, ptr %.tpc, i64 0, i32 1
%3 = getelementptr inbounds %zag.context.Context, ptr %.context, i64 0, i32 3
store ptr %1, ptr %3, align 8 ; native PC
store ptr %2, ptr %4, align 8 ; threaded PC
; ** set %5 to the dispatch send address **
; ** set %6 to the symbol value for #+ **
%8 = musttail call ptr %5(ptr undef, ptr nonnull align 8 %.sp, ptr nonnull align
8 %.process, ptr nonnull align 8 %.context, i64 %6)
ret ptr %7}

Basic Blocks
define ptr @plus_and_and_.2(ptr noundef %.pc, ptr noundef %.sp, ptr noundef %.process, ptr
noundef %.context, i64 %.signature) #1 {
%2 = load ptr, ptr %1, align 8 ; native PC
%4 = load ptr, ptr %3, align 8 ; threaded PC
%.ccontext = load ptr, ptr %5, align 8 ; caller’s context
%6 = load i64, ptr %.sp, align 8 ; result value
%.sp.1 = getelementptr inbounds %zag.context.Context, ptr %.context, i64 0, i32 9
store i64 %6, ptr %.sp.1, align 8 ; result value
%7 = musttail call ptr %2(ptr %3, ptr nonnull align 8 %.sp.1, ptr nonnull align 8 %.process
ptr nonnull align 8 %.ccontext, i64 undef)
ret ptr %7}
Result of computation
on the top of the stack

1. Connecting the LLVM IR
Builder into the runtime and
generating the JIT’ed code on
the ﬂy
2. Benchmarking results
Future Work

Smalltalk JIT Compilation: LLVM Experimentation

More Related Content

Similar to Smalltalk JIT Compilation: LLVM Experimentation (20)

More from ESUG (20)

Recently uploaded (20)

Smalltalk JIT Compilation: LLVM Experimentation