In this talk, we'll dive into the details of how various language features supported by Kotlin are translated to Java bytecode. We'll use the JMH microbenchmarking tool to study the relative performance of various constructs and to understand how we can ensure top performance of the Kotlin code that we write.

1. Kotlin Bytecode Generation
and
Runtime Performance
Dmitry Jemerov
Dmitry Jemerov, 11-13 May 2016

2. What is Kotlin

3. What is Kotlin

4. What is Kotlin
• Statically typed programming language for JVM, Android and the
browser
• Pragmatic, safe, concise, seamless Java interop

5. What is Kotlin
• Statically typed programming language for the JVM, Android and
the browser
• Pragmatic, safe, concise, seamless Java interop

6. Compiling a mixed project
*.java
kotlinc
*.kt
*.class
javac *.class
*.jar

7. Metadata
@Metadata(
mv = {1, 1, 1},
bv = {1, 0, 0},
k = 1,
d1 = {"u0000"nu0002u0018u0002nu0002u0018u0002nu0002bu0002nu0002u0010bnu0000n
u0002u0010u0002nu0002bu0005nu0002u0018u0002nu0002bu0002bu0017u0018u00002u00020u0001Bu0005¢
u0006u0002u0010u0002Jbu0010u0003u001au00020u0004Hu0007Jbu0010u0005u001au00020u0006Hu0007Jb
u0010u0007u001au00020u0004Hu0007Jbu0010bu001au00020u0004Hu0007J!u0010tu001au0002Hn"u0004b
u0000u0010n2fu0010u000bu001abu0012u0004u0012u0002Hn0fHu0002¢u0006u0002u0010r¨u0006u000e"},
d2 = {"Lorg/jetbrains/LambdaBenchmark;", "Lorg/jetbrains/SizedBenchmark;", "()V", "capturingLambda", "",
"init", "", "mutatingLambda", "noncapturingLambda", "runLambda", "T", "x", "Lkotlin/Function0;", "(Lkotlin/jvm/
functions/Function0;)Ljava/lang/Object;", "production sources for module kotlin-benchmarks"}
)
public class LambdaBenchmark extends SizedBenchmark
{ … }

8. Working with metadata
class A {
fun foo(): String? = null
fun bar(): String = ""
}
fun main(args: Array<String>) {
println(A::class.functions.filter {
it.returnType.isMarkedNullable
})
}

9. File-level functions
// Data.kt
fun foo() {
}
public final class DataKt {
public static void foo() {
}
}

10. @JvmName
@file:JvmName("FooUtils")
fun foo() {
}
public final class FooUtils {
public static final void foo() {
}
}

11. Primary constructors
class A(val x: Int) {
}
public final class A {
private final int x;
public final int getX() {
return this.x;
}
public A(int x) {
this.x = x;
}
}

12. Data classes
data class A(val x: Int) {
}
public final class A {
…
public String toString() {
return "A(x=" + this.x + ")";
}
public int hashCode() {
return this.x;
}
public boolean equals(Object o) {
…
}
}

13. Properties
class A {
var x: String? = null
}
public final class A {
@Nullable
private String x;
@Nullable
public final String getX() {
return this.x;
}
public final void setX(
@Nullable String x) {
this.x = x;
}
}

14. @JvmField
class A {
@JvmField var x: String? = null
}
public final class A {
@JvmField
@Nullable
public String x;
}

15. Not-null types
class A {
fun x(s: String) {
println(s)
}
private fun y(s: String) {
println(s)
}
}
public final class A {
public final void x(@NotNull String s) {
Intrinsics.
checkParameterIsNotNull(s, "s");
System.out.println(s);
}
private final void y(String s) {
System.out.println(s);
}
}

16. Parameter null checks
1 parameter
8 parameters
ns
0 2,25 4,5 6,75 9
Without @NotNull With @NotNull

17. Extension functions
class A(val i: Int)
fun A.foo(): Int {
return i
}
fun useFoo() {
A(1).foo()
}
public final class ExtFunKt {
public static final void foo(
@NotNull A $receiver) {
return $receiver.getI();
}
}
public static final void useFoo() {
foo(new A(1));
}

18. Interface methods
interface I {
fun foo(): Int {
return 42
}
}
class C : I {
}
public interface I {
int foo();
public static final class
DefaultImpls {
public static int foo(I $this) {
return 42;
}
}
}
public final class C implements I {
public void foo() {
I.DefaultImpls.foo(this);
}
}

19. Interface methods: Evolution
interface I {
fun foo(): Int {
return 42
}
fun bar(): Int {
return 239
}
}
// -- separate compilation ——————
class C : I {
}
public interface I {
int foo();
int bar();
public static final class
DefaultImpls { … }
}
// -- separate compilation ——————
public final class C implements I {
public void foo() {
I.DefaultImpls.foo(this);
}
}

20. Default Arguments
fun foo(x: Int = 42) {
println(x)
}
fun bar() {
foo()
}
public static final void foo(int x) {
System.out.println(x);
}
public static void foo$default(
int x, int mask, …) {
if ((mask & 1) != 0) {
x = 42;
}
foo(x);
}
public static final void bar() {
foo$default(0, 1, …);
}

21. Default Arguments
1 parameter
8 parameters
ns
0 3,75 7,5 11,25 15
Without default values With default values

22. @JvmOverloads
@JvmOverloads
fun foo(x: Int = 42) {
}
public static final void foo(int x)
{
}
public static void foo$default(
int x, int mask, …) { … }
public static void foo() {
foo$default(0, 1, …);
}

23. Lambdas: Functional types
fun <T> runLambda(x: () -> T): T =
x()
private static final
Object runLambda(Function0 x) {
return x.invoke();
}
package kotlin.jvm.functions
/** A function that takes 0 arguments. */
public interface Function0<out R> : Function<R> {
/** Invokes the function. */
public operator fun invoke(): R
}

24. Lambdas: Noncapturing
var value = 0
fun noncapLambda(): Int
= runLambda { value }
final class LB$noncapLambda$1
extends Lambda implements Function0 {
public static final LB$noncapLambda$1
INSTANCE = new LB$noncapLambda$1();
public final int invoke() {
return LambdaBenchmarkKt.getValue();
}
}
public static int noncapLambda() {
return ((Number)runLambda(
LB$noncapLambda$1.INSTANCE)
).intValue();
}

25. Lambdas: Capturing
fun capturingLambda(v: Int): Int
= runLambda { v }
public static int
capturingLambda(int value) {
return ((Number)RL.runLambda(
new Function0(0) {
public final int invoke() {
return value;
}
})
).intValue();

26. Lambdas: Capture and mutate
fun mutatingLambda(): Int {
var x = 0
runLambda { x++ }
return x
}
public static int mutatingLambda()
{
final IntRef x = new IntRef();
x.element = 0;
RL.runLambda(new Function0(0) {
public final int invoke() {
int var1 = x.element++;
return var1;
}
});
return x.element;
}
public static final class IntRef {
public volatile int element;
@Override
public String toString() {
return String.valueOf(element);
}
}

27. Lambdas
Noncapturing
Capturing
Mutating
ns
0 45 90 135 180
Java Kotlin

28. Lambdas: inline
fun inlineLambda(x: Int): Int =
run { x }
public static int
inlineLambda(int x) {
return x;
}
/**
* Calls the specified function [block] and returns its result.
*/
public inline fun <R> run(block: () -> R): R = block()

29. Method References
private fun referenced() = 1
fun runReference() {
runLambda(::referenced)
}
final class MethodReferenceKt$runReference$1
extends FunctionReference implements Function0
{
public static final MethodReferenceKt
$runReference$1 INSTANCE = new
MethodReferenceKt$runReference$1();
public final int invoke() {
return MethodReferenceKt.access
$referenced();
}
public final KDeclarationContainer
getOwner() { … }
public final String getName() { … }
public final String getSignature() { … }
}

30. Loops: Range
fun rangeLoop() {
for (i in 1..10) {
println(i)
}
}
public static final void
rangeLoop() {
int i = 1;
byte var1 = 10;
if(i <= var1) {
while(true) {
System.out.println(i);
if(i == var1) {
break;
}
++i;
}
}
}

31. Loops: Array
fun arrayLoop(x: Array<String>) {
for (s in x) {
println(s)
}
}
public static void
arrayLoop(@NotNull String[] x) {
for(int var2 = 0;
var2 < x.length; ++var2) {
String s = x[var2];
System.out.println(s);
}
}

32. Loops: List
fun listLoop(x: List<String>) {
for (s in x) {
println(s)
}
}
public static final void
listLoop(@NotNull List x) {
Iterator var2 = x.iterator();
while(var2.hasNext()) {
String s =
(String)var2.next();
System.out.println(s);
}
}

33. Loops
Range
Array
ArrayList
ns
0 27,5 55 82,5 110
Java Kotlin

34. When: Table lookup
fun tableWhen(x: Int): String =
when(x) {
0 -> "zero"
1 -> "one"
else -> "many"
}
public static String tableWhen(int x)
{
String var10000;
switch(x) {
case 0:
var10000 = "zero";
break;
case 1:
var10000 = "one";
break;
default:
var10000 = "many";
}
return var10000;
}

35. When: Constants
val ZERO = 0
val ONE = 1
fun constWhen(x: Int): String =
when(x) {
ZERO -> "zero"
ONE -> "one"
else -> "many"
}
public static String constWhen(
int x) {
return x == ZERO ? “zero"
: (x == ONE ? “one" : "many");
}

36. When: enum
enum class NumberValue {
ZERO, ONE, MANY
}
fun enumWhen(x: NumberValue):
String = when(x) {
NumberValue.ZERO -> "zero"
NumberValue.ONE -> "one"
else -> "many"
}
public static String
enumWhen(@NotNull NumberValue x) {
String var10000;
switch(WhenEnumKt$WhenMappings.
$EnumSwitchMapping$0[x.ordinal()]) {
case 1:
var10000 = "zero";
break;
case 2:
var10000 = "one";
break;
default:
var10000 = "many";
}
return var10000;
}

37. When
Lookup
Compare
Enum
ns
0 5,5 11 16,5 22
Java Kotlin

38. Summary
• Kotlin allows writing code which is easy to use from Java
• Performance in most scenarios is on par with Java
• Inline functions 👍
• Measure the performance of your code, not micro-examples

39. https://www.manning.com/books/kotlin-in-action

40. Q&A
yole@jetbrains.com
@intelliyole