Cloud Native Java:GraalVM

Copyright © 2017, Oracle and/or its affiliates. All rights reserved. | Confidential – Oracle Internal/Restricted/Highly Restricted 1
Oracle
Developer
Meetup8
th
김태완
taewanme@gmail.com
@taewanme
Cloud Native Java: GraalVM
2019.02.16

Copyright © 2017, Oracle and/or its affiliates. All rights reserved. |
About: 김 태완(@taewanme)
• taewanme@gmail.com
• 1999 ~ 2006 Java (SI, Developer)
• 2007 ~ 2013 Middleware Engineer
– WAS, Memory Cache, CEP, DB Replication
• 2013 ~ 2014 CouchDB, Erlang (SE)
• 2015 ~ Big Data, ML, Deep Learning(SC)
http://taewan.kim

Demo code
• https://github.com/taewanme/graalvm_seminar_examples
Confidential – Oracle Internal/Restricted/Highly Restricted 3

Graal Truffle

Java의 3대 전환점
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 2019

Java의 3대 전환점: Java 1.2 à Enterprise
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12
1998.12 è Java SE 1.2
1999.12 è Java EE 1.2
2000.05 è Java SE 1.3

Java의 3대 전환점: OpenSource Community 주도
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12 2006.05
Java EE 5.0

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12 2006.05
Java EE 5.0
POJO
Dependency Injection

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12 2006.05
Java EE 5.0
POJO
Dependency Injection
StandardizationStandardization

Java의 3대 전환점: OpenJDK à 다양성 자바
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12 2006.05

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
1996 20191999.12 2006.05
Excelsior JET
Java Virtual Machine

GraalVM
http://www.graalvm.org/

Why GraalVM?
8. Java code as a native library
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
9. Polyglot in the database
10. Create your own languagehttps://chrisseaton.com/truffleruby/tenthings/

Why GraalVM?
10. Create your own language

Why GraalVM?
10. Create your own language
IoT
Polyglot
Cloud Native

생각해 볼 거리
Static(AOT) vs Dynamic(JIT)
Compiler
Java vs C/C++

Java와 C/C++

{AOT, JIT} Compiler

Compiler
• AOT(Ahead-of-Time) Compiler
• JIT (Just-In-Time) Compiler
Static vs Dynamic
Compiler

AOT 컴파일러와 Dynamic 컴파일러 차이점
AOT
Compiler
JIT
Compiler
è Machine Code è Machine Code

AOT Compiler JIT Compiler
Source code → Native executable Source code → Bytecode →
Interpreter + JIT executable
실행전에 무겁고 복잡한 분석&최적화 수행
실행 환경 정보 수집 어려움
특정 환경 특화된 최적화가 어려움
공격적이고 낙관적인 최적화
실행 프로파일 정보를 활용
특정 환경 특화된 최적화가 용이

Write Once, Run Anywhere
이미지 출처: https://commons.wikimedia.org/wiki/File:Java-program-execution.png

- javac compiler
- Java code(String) è byte[]
- java 파일을 Binary Representation
- compact & small
- JIT compiler
- byte[] è byte[] (machine code)
- compact & small representation

- Runtime
- 클래스 로딩, 바이트코드 검증, 동기화
- JIT
- 프로파일링, 컴파일 계획, OSR
- Aggressive Optimization
- GC
- Throughput & Response Time에 따른 알고리즘

JIT Compiler의 목표
빠른 컴파일 속도 & 최적화

Bytecode 실행
2
3
4
1
Interpretation
Profiling
Dynamic Compilation
Deoptimization

JIT Compiler
• Speculation Without Regret: Reducing Deoptimization Meta-data in the
Graal compiler
http://ssw.jku.at/General/Staff/GD/PPPJ-2014-duboscq-29.pdf
JVM

HotSpot Optimization

Optimization: inlining
int addAll(int max){
int accum = 0;
for(int i = 0; i<max; i++) {
accum = add (accum, i);
}
return accum;
}
int add(int a, int b){return a+b;}
int addAll(int max){
int accum = 0;
for(int i = 0; i<max; i++) {
accum = accum + i;
}
return accum;
}
Optimization: inlining

JVM 성능 향상
http://www.dominicgiles.com/blog/files/abdb7a96e9db63644317c62d6e40c40b-142.html

JVM 성능 향상 주체
• JIT Compiler
– Profiling &
• CPU, Memory, Object Tracking, Mem
– Optimization
• 더 효율적인 코디 패턴 감지
• 더 효율적인 머신 코드 생성
http://ssw.jku.at/General/Staff/GD/PPPJ-2014-duboscq-29.pdf

Quiz: 누가 더 빠를까요?
Linux Linux
Java Java

Oracle & Intel

Intel CPU의 Java 최적화

HotSpot

HotSpot
• Oracle Java JVM
• Java SE 1.3(1999. 04)에 추가
• 개발 언어: C++
• 2개의 JIT compiler를 포함
– C1: client compiler
• C1 디자인: 빠른 시작
• 코드 최적화의 비중 낮춤
– C2: server compiler
• C2 디자인: 약간 느린 시작
• 코드 최적화 비중 높임
HotSpot VM
C1 C2
Compiler Interface
HotSpot VM
c++
c++
c++
c++

HotSpot – JVM
• client / C1
– $ java –client
– 32-bit VM
– machine code 생성 속도 빠름
– 기본 최적화
– 프로파일 지원하지 않음
– 장점: 빠른 시작
– 단점: 최대 성능 저하
• server / C2
– $ java –server
– 32-bit VM
– 코드 최적화 수준 높음
– 프로파일 기반 최적화
– C++과 비슷하거나 더 빠른 코드를
생산
– gcc 와 같은 AOT 컴파일러가 할 수
없는 런타임 최적화를 적용
– 장점: 머신코드 품질이 좋음
– 단점: 느린 시작, warmup 필요

HotSpot – Tiered Compilation
• -XX:+TieredCompilation
• 기본 JIT 컴파일 설정
• Level
– Level0: Interpreter
– Level1: C1, 프로파일 없음
– Level2: C1, 기본 프로파일
– Level3: C1, 완전 프로파일
– Level4: C2
Time to Performance
Peak Performance

JVM

HotSpot – Limitation
https://github.com/netroby/jdk9-
dev/blob/master/jdk/src/java.base/share/classes/jdk/internal/HotSpotIntrinsicCandidate.java

GraalVM & Graal

GraalVM에 들어가기 앞서 다시한번….
Static(AOT) vs Dynamic(JIT)
Compiler
Java vs C/C++

GraalVM
GraalVM = Hotspot VM+ 𝜶

GraalVM Team

OMZ……

GraalVM의 핵심 키워드
Graal / JVMCI Polyglot/ Truffle Native Image
NEW JIT Complier Language Platform AOT Compiler

GraalVM 키워드
• Graal
• GraalVM
• Polyglot
• Truffle
• Substrate VM
• JVMCI, Compiler Interface
• JIT Compiler
• AOT
• HotSpotVM

Graal != GraalVM
HotSpot VM
C1 C2
Compiler Interface
OpenJDK 8
HotSpot VM
Compiler Interface JVMCI
C1 Graal
GraalVM

Graal
• GraalVM의 새로운 JIT Compiler
• Hotspot의 C2 JIT 컴파일러 대체가 목표
• Java로 개발
• C2와 비교하여 20% 선능 개선 (Twitter 사례)
– Production Scala 애플리케이션에 적용
– GraalVM CE(Community Edition)
https://www.youtube.com/watch?v=ZbccuoaLChk

Community Edition
• Free
• Unsupported
• Runs all GraalVM languages
– Java (+Scala), JavaScript, Python, Ruby, R
• Support for native libraries in context of those languages too
– Tools (debugger, profiler, monitor agent)
• Basic version of SubstrateVM
– Native code has full access to address space
• Runs code in JVM, Node.js, MySQL, or standalone
Enterprise Edition
• Not Free
• Supported
• Best performance & size
– Graal EE Java is 20% faster than CE (on average)
– Dynamic languages (JS, Python, R, Ruby) 2x faster
– Smallest footprint – 2x smaller vs CE
• Native code memory protection
• Debugging tools for embedded use
GraalVM 라이센스

Scala 2.12.6 & GraalVM
https://medium.com/graalvm/compiling-scala-faster-with-graalvm-86c5c0857fa3

graal compiler
• OpenJDK 9 +
• OpenJDK 10 +
• OpenJDK 11 +
• GraalVM
-XX:+UnlockExperimentalVMOptions
-XX:+UseJVMCICompiler
-XX:+EnableJVMCI

GraalVM 설치
# 다운로드
$ wget https://github.com/oracle/graal/releases/download/vm-1.0.0-
rc12/graalvm-ce-1.0.0-rc12-macos-amd64.tar.gz
# 압축풀기
$ tar zxf graalvm-ce-1.0.0-rc12-macos-amd64.tar.gz
# 환경 변수
$ export GRAAL_HOME=…
$ PATH=PATH=$GRAAL_HOME/bin:$PATH

GraalVM 설치

graal compiler
https://www.graalvm.org/docs/examples/java-performance-examples/

graal compiler Demo
OpenJDK 11, Tiered Compiler OpenJDK 11, Graal Compiler

graal compiler Demo: compile log

Graal과 Twitter
https://www.youtube.com/watch?v=G-vlQaPMAxg

GraalVM 기능과 JEP
• JEP: JDK Enhancement Proposal

Native Image

작은 footprint, 신속한 startup
OpenJDK 11, Graal Compiler
SubstrateVM (SVM)
• GraalVM의 하위 프로젝트
• JVM 애플리케이션을 컴파일하여 Native 실행파일을 생성
• Ahead-of-time compiler- 빠른 시작을 유도
• Virtual 머신이 필요 없음
• 작은 메모리로 시작
• 38Mbyte virt.x 애플리케이션을 10MB RAM에서 돌린 사례
• https://www.jetdrone.xyz/2018/08/10/Vertx-native-image-
10mb.html

Native Image Demo

Graal & SubstrateVM

빠른 Startup: Heap Image
• d
https://medium.com/graalvm/isolates-and-compressed-references-more-flexible-and-
efficient-memory-management-for-graalvm-a044cc50b67e

Substrate VM Java Limitations
https://github.com/oracle/graal/blob/master/substratevm/LIMITATIONS.md
항목 지원
Dynamic Class Loading / Unloading Not supported
Reflection Mostly supported
Dynamic Proxy Mostly supported
Java Native Interface (JNI) Mostly supported
Unsafe Memory Access Mostly supported
Static Initializers Partially supported
InvokeDynamic Bytecode and Method Handles Not supported
Finalizers Not supported
References Mostly supported
Security Manager Not supported
JVMTI, JMX, other native VM interfaces Not supported

Micronaut의 GraalVM 지원

GraalVM 기능과 JEP

Polyglot

Truffle

Polyglot Virtualization
75
Truffle API
Java Runtime
JavaScript
Interpreter
Ruby
Interpreter
R
Interpreter
Python
Interpreter
GraalVM
compiler
Compiled
code snippetCompiled
code snippet

76
Truffle API
Java Runtime
JavaScript
Interpreter
Ruby
Interpreter
R
Interpreter
Python
Interpreter
GraalVM
compiler
Compiled
code snippet
…JavaScript
application
JavaScript
libraries
Node.js
Ruby
application
Ruby gems
& libraries
Rails

77
Truffle API
Java Runtime
JavaScript
Interpreter
Ruby
Interpreter
R
Interpreter
Python
InterpreterGraalVM
compiler
Compiled
code snippet
…JavaScript
application
JavaScript
libraries
Node.js
Ruby
application
Ruby gems
& libraries
Rails

7878
Truffle API
Java Runtime
JavaScript
Interpreter
Ruby
Interpreter
R
Interpreter
Python
Interpreter
GraalVM
compiler
Compiled
code snippet
JavaScript
application
JavaScript
libraries
Node.js
…Ruby
application
Ruby gems
& libraries
Rails
LLVM .bc
Interpreter
R native
libraries
Node.js
native libs
Ruby/Rails
native libs

79
Truffle API
JavaVM Runtime
JavaScript
Interpreter
Ruby
Interpreter
R
Interpreter
Graal
compiler
Compiled
code snippet
JavaScript
application
JavaScript
libraries
Node.js
…
Ruby
application
Ruby gems
& libraries
Rails
LLVM .bc
Interpreter
R native
libraries
Node.js
native libs
Ruby/Rails
native libs
Threads / Scheduler Filesystem Network GC / heap Code cache
Java
application
Truffle
Polyglot
API
eval("application/x-ruby",
"def add(a, b) a + b;
end;");

Truffle

Ployglot Performance

Java에서 다른 언어 호출
import org.graalvm.polyglot.*;
public class Sample {
public static void main(String[] args) {
try (Context context = Context.newBuilder().allowAllAccess(true).build()){
System.out.println( context.getEngine().getLanguages().keySet());
context.eval("ruby", "puts '안녕, 루비’”);
context.eval("python", "print(안녕, 파이썬')");
context.eval("js", "console.log(‘안녕, JS')");
context.eval("R", "cat(‘안녕, R')");
} catch (PolyglotException e) {
e.printStackTrace();
}
}
}
graaldemo/example/e04

spring-r: mvn spring-boot:run
example/e06/spring-r

Spring-r UI: http://localhost:8080/load
example/e06/spring-r

Java에서 다른 언어를 호출 (LLVM)
#include <stdio.h>
int main(){
print(“Hello from graalvm!n”);
return 0;
}
$ clang -c -O1 -emit-llvm hello.c
$ lli hello.bc
Hello from graalvm!
$

Java에서 다른 언어를 호출 (LLVM)
import org.graalvm.polyglot.*;
import java.io.*;
public class Sample {
public static void main(String[] args) throws Exception {
File f = new File("hello.bc");
Source source = Source.newBuilder("llvm", new File("hello.bc")).build();
try (Context context = Context.newBuilder().allowAllAccess(true).build()){
context.eval(source).execute();
}
}
}

PolyGlot Demo
public class Test {
public static String getString() {
return "Hello from Java! <br> ";
}
}
87
Test.java

PolyGlot Demo
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! '
// Using Java standard library classes
text += BigInteger.valueOf(2).pow(100).toString(16)
text += ' '
// Using custom Java class
text += Java.type('Test').getString()
// Using R methods to return arrays
text += Interop.eval('application/x-r', 'runif(1000)')[0]
// Using R interoperability to create graphs
text += Interop.eval('application/x-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!')
})
88
server.js

PolyGlot Demo
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! '
89
server.js

PolyGlot Demo (2)
// Using Java standard library classes
text += BigInteger.valueOf(2).pow(100).toString(16)
text += ' '
// Using custom Java class
text += Java.type('Test').getString()
90
server.js

PolyGlot Demo (3)
// Using R methods to return arrays
text += Interop.eval('application/x-r', 'runif(1000)')[0]
91
server.js

PolyGlot Demo (4)
// Using R interoperability to create graphs
text += Interop.eval('application/x-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)
})
92
server.js

PolyGlot Demo (5)
app.listen(3000, function () {
console.log('Example app listening on port 3000!')
})
93
server.js

Ployglot Database

GraalVM Summary

GraalVM
Confidential – Oracle Internal
Languages Graal Embeddings* *
Java
JavaScript
Ruby
R
Python
C/C++. FORTRAN, …
HotSpot JVM
MySQL
Oracle RDBMS
Spark
nginx
…
Optimizations
Tooling
Interoperability
Code

GraalVM의 목표: Six degrees of freedom
https://commons.wikimedia.org/wiki/File:6DOF.svg
• Fast Startup Java Application: Native
• High Performance Java Application
• Integrated Polyglot Application
• Java as Language Platform
• Embedded Java Application

GraalVM, OpenJDK, Oracle Java
Graal
Native Image
JVMCI
JEP 243: Java-Level JVM Compiler Interface
JEP 295: Ahead-of-Time Compilation
JEP 317: Experimental Java-Based JIT Compiler

GraalVM의 비전
언어에 자유롭고, 빠르고, 자유도가 높은 가상머신
Write code once (in whatever language you want) and use it in any
application written in any other language, and run it in whatever engine you
want (Java HotSpot, Node.js, MySQL, Oracle RDBMS, or standalone)
Already In Production

GraalVM
• Fastest Runtime
– Faster in standard JVM – Twitter says EE is 30% faster, Morgan Stanley reports 35%
– Native Image Mode compiles Java code into standalone binaries - no JVM required
• Multilingual w/ high compatibility (eg. runs Node.js & Java in one process)
• More secure (runs native libraries in bounds-checked & GC’ed mode)
• Embeddable (run in a device, native or JVM-based engine) with low overhead
Null method in Function-as-a-Service JDK8 Go GraalVM EE
Cold Execution (w/o Docker) 210 ms 20 ms 10 ms
Container Memory 17.8 MB 1.2 MB 0.9 MB
Container Image Size 266 MB 15.1 MB 13.6 MB Serverless Compute
Footprint & Startup

Cloud Native Java:GraalVM

More Related Content

What's hot

Similar to Cloud Native Java:GraalVM

Recently uploaded