After many years of development, Oracle finally published GraalVM and sparkled a lot of interest in the community. GraalVM is a high-performance polyglot VM with a number of potentially interesting traits we can take advantage of like increased performance and lowered cost. It can also tackle shortcomings of JVM/Scala we are struggling for years like slow-startup times or large jars. Lastly, thanks to its polyglot nature it can open interesting doors we may want to discover. On the other hand, GraalVM may still be bleeding edge technology and having a hard time to deliver the promised features. In this talk, I’d like to discuss advantages and disadvantages of adopting GraalVM, provide you guidance if you decide to do so and also share our story in this area including various samples, and recommendations. This talk is focused on JVM and Scala but should be beneficial for everyone with interested in this topic.

1. Adopting GraalVM
@petr_zapletal

3. GraalVM: Run Programs Faster Anywhere

4. Compiling with GraalVM

6. sbt --java-home <path-to-graal-vm>

7. -XX:+UnlockExperimentalVMOptions
-XX:+EnableJVMCI
-XX:+UseJVMCICompiler

8. ● JDK 10/11 requires Scala 2.13
Limitations & Challenges

9. ● JDK 10/11 requires Scala 2.13
● Limited library support
Limitations & Challenges

10. ● JDK 10/11 requires Scala 2.13
● Limited library support
● Scaladex
Limitations & Challenges

11. ● JDK 10/11 requires Scala 2.13
● Limited library support
● Scaladex
● Disabling compiler optimization
Limitations & Challenges

13. JDK 11
[success] Total time: 571 s, ...
real 12m48.492s
user45m40.264s
sys 2m31.045s
vs.
Graal
(using the flags)
[success] Total time: 507 s, ...
real 11m34.191s
user41m52.512s
sys 2m12.863s
Stopwatch Compiling

14. GraalVM Runtime
Just-in-time compilation

15. Compilation & JVM
Just-in-time (JIT)
● Compiles while running
● Dynamic compilation
● Runtime information
● De-optimization
● Typical for JVM
Ahead-of-time (AOT)
● Compiles before running
● Static compilation
● More resources
● Way more time
● Uncommon for JVM (JDK 9+)

16. java -XX:+UnlockExperimentalVMOptions
-XX:+EnableJVMCI
-XX:+UseJVMCICompiler

17. object Main extends App {
val max = 10000000
def isPrime(n: Int): Boolean =
primes.takeWhile(p => p*p <= n).forall(n % _ != 0)
val primes = 2 #:: Stream.from(3,2).filter(isPrime)
primes.takeWhile(_ <= max).toList
}
Primes

18. Primes
object Main extends App {
val max = 10000000
def isPrime(n: Int): Boolean =
primes.takeWhile(p => p*p <= n).forall(n % _ != 0)
val primes = 2 #:: Stream.from(3,2).filter(isPrime)
primes.takeWhile(_ <= max).toList
}

19. Primes
object Main extends App {
val max = 10000000
def isPrime(n: Int): Boolean =
primes.takeWhile(p => p*p <= n).forall(n % _ != 0)
val primes = 2 #:: Stream.from(3,2).filter(isPrime)
primes.takeWhile(_ <= max).toList
}

20. Primes
object Main extends App {
val max = 10000000
def isPrime(n: Int): Boolean =
primes.takeWhile(p => p*p <= n).forall(n % _ != 0)
val primes = 2 #:: Stream.from(3,2).filter(isPrime)
primes.takeWhile(_ <= max).toList
}

21. jdk 1.8.0_161-b12
time <path-to-java>/java -jar
primes.jar
real 0m11.646s
user0m14.286s
sys 0m0.657s
vs.
graalvm-ee-1.0.0-rc8
time <path-to-graal>/java
-XX:+UnlockExperimentalVMO
ptions
-XX:+EnableJVMCI
-XX:+UseJVMCICompiler
-jar primes.jar
real 0m13.478s
user0m29.199s
sys 0m0.975s
Primes

23. class Primes {
@Benchmark
@BenchmarkMode(Array(Mode.AverageTime))
@OutputTimeUnit(TimeUnit.MICROSECONDS)
def getPrimes() = primes.takeWhile(_ <= max).toList
}
object Main extends App {
new Primes().getPrimes()
}
Primes II

24. class Primes {
@Benchmark
@BenchmarkMode(Array(Mode.AverageTime))
@OutputTimeUnit(TimeUnit.MICROSECONDS)
def getPrimes() = primes.takeWhile(_ <= max).toList
}
object Main extends App {
new Primes().getPrimes()
}
Primes II

25. jdk 1.8.0_161-b12
jmh:run -i 10 -wi 10 -f4 -t4
Primes
[info] Benchmark Mode Cnt
Score Error Units
**[info] Primes.getPrimes
avgt 40 45652.951 ±
2083.281 us/op**
vs.
graalvm-ee-1.0.0-rc8
jmh:run -i 10 -wi 10 -f4 -t4
Primes
[info] Benchmark Mode Cnt
Score Error Units
**[info] Primes.getPrimes
avgt 40 40535.844 ±
1977.021 us/op**
Primes II

26. (Early) Adopters

27. GraalVM Runtime
Ahead-of-time compilation

28. <path-to-graal>/bin/native-image

29. ● JVM starts slowly
● Scala makes it worse
● JARs bloat up quickly
JVM Shortcomings

30. JDK 1.8 (JIT)
time java -jar primes.jar
real 0m0.555s
user 0m0.613s
sys 0m0.075s
vs.
GraalVM (AOT)
<path-to-graal>/bin/native-i
mage -jar primes.jar
time ./primes
real 0m0.039s
user 0m0.004s
sys 0m0.010s
Counting Primes

31. JDK 1.8 (JIT)
time java -jar primes.jar
real 0m11.954s
user 0m14.077s
sys 0m0.739s
vs.
GraalVM (AOT)
<path-to-graal>/bin/native-i
mage -jar primes.jar
time ./primes
Segmentation fault: 11
real 0m0.324s
user 0m0.245s
sys 0m0.077s
Counting Primes

32. ● Small programs/scripts
● Alexa apps
● AWS Lambdas (using GO
runtime)
Use Cases

33. Do you want to use Scala
in cases like these?

34. There is More

35. Summary

36. Questions

37. References

38. References
● https://github.com/scala/make-release-notes/blob/2.13.x/projects-2.13.md
● https://index.scala-lang.org/search?q=fullScalaVersion%3A2.13.0-M5
● https://github.com/oracle/graal/blob/master/substratevm/LIMITATIONS.md
● https://www.youtube.com/watch?v=Rvb-kvuPzqI
● https://github.com/chrisseaton/graalvm-ten-things
● https://www.youtube.com/watch?v=wBegU4d4GRc
● https://engineering.opsgenie.com/run-native-java-using-graalvm-in-aws-lambda-with-golan
g-ba86e27930bf
● https://medium.com/graalvm/instant-netty-startup-using-graalvm-native-image-generation-
ed6f14ff7692
● https://www.infoq.com/articles/Graal-Java-JIT-Compiler
● https://medium.com/graalvm/compiling-scala-faster-with-graalvm-86c5c0857fa3

39. Images
● https://cdn.app.compendium.com/uploads/user/e7c690e8-6ff9-102a-ac6d-e4aebca50
425/d7eaeb73-4b9e-4764-ad10-b5785d99d114/Image/497cab5d0638a34c8a08194ef
b83b2fc/announcing_graalvm_version7.png
● https://cdn-images-1.medium.com/max/2000/1*rHZFwj8uu-x8KVCItuu53Q.png
● https://unsplash.com/photos/4m7gmLNr3M0
● https://www.tecflow.com/uk/images/slechte-koude-start-tecflow.jpg