Inline functions and performance in Kotlin - Deep Dive

Overview - Inline functions and performance

What is it?

Inline functions in Kotlin are special functions where the compiler replaces the function call with the actual function code during compilation. This means the function's code is copied directly into the places where it is called. This helps avoid the usual overhead of calling a function, making the program run faster. Inline functions are often used with lambda expressions to improve performance.

Why it matters

Without inline functions, every function call adds a small delay because the program has to jump to the function and then come back. This can slow down programs, especially when functions are called many times or when using lambdas. Inline functions remove this delay, making apps smoother and faster, which is important for things like games or apps on slow devices.

Where it fits

Before learning inline functions, you should understand basic Kotlin functions and lambda expressions. After mastering inline functions, you can explore advanced topics like higher-order functions, reified types, and performance optimization techniques in Kotlin.

Mental Model

Core Idea

Inlining means replacing a function call with the actual function code to save time and improve performance.

Think of it like...

Imagine you have a recipe card for making a sandwich. Normally, you might ask a friend to read the recipe every time you want a sandwich (function call). Inlining is like copying the recipe directly onto your kitchen counter so you don’t have to ask your friend each time, saving you time.

┌───────────────┐       ┌───────────────┐
│ Call function │──────▶│ Jump to code  │
└───────────────┘       └───────────────┘

Becomes:

┌─────────────────────────────┐
│ Function code copied inline  │
│ No jump, runs directly here  │
└─────────────────────────────┘

Build-Up - 6 Steps

1

Foundation

What are Kotlin functions

Concept: Understanding the basics of functions in Kotlin.

Functions are blocks of code that do a specific job. You write a function once and call it whenever you need it. For example: fun greet() { println("Hello!") } greet() // Calls the function to print Hello!

Result

When you run greet(), it prints 'Hello!' to the screen.

Knowing how functions work is essential because inline functions are a special kind of function that changes how calls happen.

2

Foundation

Understanding lambda expressions

Concept: Introducing lambdas as small blocks of code passed around like variables.

A lambda is a way to write a function without a name. For example: val sayHello = { println("Hi!") } sayHello() // Calls the lambda Lambdas are often used as arguments to other functions.

Result

Calling sayHello() prints 'Hi!' to the screen.

Lambdas let you write flexible code, but they can add extra work when called many times.

3

Intermediate

What inline functions do

🤔Before reading on: do you think inline functions run slower or faster than normal functions? Commit to your answer.

Concept: Inline functions replace calls with actual code to avoid call overhead.

When you mark a function as inline in Kotlin, the compiler copies its code directly where it is called instead of making a jump. For example: inline fun greet() { println("Hello inline!") } greet() // The println code is copied here during compilation.

Result

The program runs faster because it skips the jump to the function.

Understanding that inline functions remove call overhead helps you write faster code, especially when using lambdas.

4

Intermediate

Inline functions with lambdas

🤔Before reading on: do you think lambdas inside inline functions create extra objects or not? Commit to your answer.

Concept: Inlining helps avoid creating extra objects when passing lambdas.

Normally, passing a lambda creates an object in memory. But if the function is inline, the lambda code is also copied inline, so no extra object is made. For example: inline fun operate(action: () -> Unit) { action() } operate { println("Running lambda") } This avoids extra memory use and speeds up the program.

Result

The lambda runs directly without creating extra objects, improving performance.

Knowing that inline functions reduce memory use with lambdas helps prevent slowdowns in tight loops or frequent calls.

5

Advanced

Using reified types in inline functions

🤔Before reading on: can you use type checks on generic types without inline functions? Commit to your answer.

Concept: Inline functions allow special features like reified types for type checks at runtime.

Normally, generic types are erased at runtime, so you can't check their type. But with inline functions and the 'reified' keyword, Kotlin keeps the type info. For example: inline fun isType(value: Any) = value is T println(isType("Hello")) // true This is only possible because the function is inline.

Result

You can check types of generic parameters at runtime, which is usually impossible.

Understanding reified types unlocks powerful generic programming patterns that depend on inline functions.

6

Expert

Performance trade-offs and code size

🤔Before reading on: do you think inlining always improves performance without any downsides? Commit to your answer.

Concept: Inlining improves speed but can increase the size of the compiled code, affecting memory and cache.

Inlining copies code everywhere the function is called. If the function is large or called many times, this can make the program bigger. Bigger programs can use more memory and slow down CPU cache, hurting performance. So, use inline functions wisely. Example: Inlining a small function called 1000 times is good. Inlining a big function called 1000 times can be bad.

Result

You get faster calls but possibly larger program size, which can slow down some parts.

Knowing when to inline and when not to is key to balancing speed and memory in real apps.

Under the Hood

At compile time, the Kotlin compiler finds calls to inline functions and replaces each call with the actual function body code. This eliminates the need for a jump instruction and stack frame setup for the call. For lambdas passed to inline functions, the compiler also copies their code inline, avoiding creating function objects and reducing heap allocations. This reduces runtime overhead but increases the compiled code size.

Why designed this way?

Inline functions were introduced to solve the performance cost of higher-order functions and lambdas in Kotlin. Before inline functions, passing lambdas created many small objects and function calls, slowing down programs. The design balances performance gains with code size increase, giving developers control over optimization.

Call site code
  │
  ▼
┌─────────────────────┐
│ Inline function call │
└─────────────────────┘
  │ compile-time replace
  ▼
┌───────────────────────────────┐
│ Function body code inserted    │
│ directly at call site          │
│ (no jump, no extra objects)    │
└───────────────────────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does marking a function inline always make your program faster? Commit yes or no.

Common Belief: Inline functions always make code faster with no downsides.

Reality: Inlining can increase the size of the compiled code, which may hurt performance due to CPU cache misses and larger binaries.

Why it matters: Blindly inlining large functions can cause slower programs and bigger app sizes, especially on memory-limited devices.

Quick: Do inline functions eliminate all function call overhead? Commit yes or no.

Common Belief: Inline functions remove all overhead of function calls, including runtime checks and allocations.

Reality: Inline functions remove call overhead but do not eliminate all runtime costs, such as complex computations inside the function.

Why it matters: Expecting inline functions to fix all performance issues can lead to ignoring other costly operations in code.

Quick: Can you use non-inline lambdas inside inline functions without performance loss? Commit yes or no.

Common Belief: Lambdas inside inline functions are always inlined and never create objects.

Reality: Only lambdas passed as parameters to inline functions are inlined; lambdas created inside the function body are not automatically inlined.

Why it matters: Misunderstanding this can cause unexpected memory allocations and slowdowns.

Quick: Can you use reified type parameters without inline functions? Commit yes or no.

Common Belief: Reified type parameters can be used in any function with generics.

Reality: Reified type parameters require the function to be inline because type information is only available at compile time during inlining.

Why it matters: Trying to use reified types in non-inline functions causes compilation errors and confusion.

Expert Zone

1

Inlining small functions called many times reduces call overhead but can increase instruction cache pressure if overused.

2

Using 'noinline' keyword inside inline functions selectively prevents inlining of certain lambdas to control code size and performance.

3

Reified type parameters enable advanced reflection-like capabilities without runtime cost, but only inside inline functions.

When NOT to use

Avoid inline functions for large functions or functions called rarely to prevent code bloat. Use regular functions or consider other optimizations like tail recursion or memoization instead.

Production Patterns

In production Kotlin code, inline functions are commonly used in standard library functions like 'let', 'apply', and 'run' to optimize lambda-heavy code. Developers selectively inline performance-critical small functions and use 'noinline' to exclude large lambdas.

Connections

Compiler optimizations

Inline functions are a form of compiler optimization that replaces function calls with code expansion.

Understanding inline functions helps grasp how compilers improve performance by transforming code before running it.

Memory management

Inlining reduces heap allocations by avoiding lambda object creation.

Knowing inline functions clarifies how memory use and performance are linked in managed languages like Kotlin.

Unrolling loops in CPU architecture

Both inline functions and loop unrolling expand code to reduce overhead and improve speed.

Recognizing this similarity shows how different fields use code expansion to optimize performance.

Common Pitfalls

#1 Inlining large functions everywhere causing big app size.

Wrong approach:

inline fun bigFunction() {
// hundreds of lines of code
}

fun main() {
repeat(1000) { bigFunction() }
}

Correct approach:

fun bigFunction() {
// hundreds of lines of code
}

fun main() {
repeat(1000) { bigFunction() }
}

Root cause:

Misunderstanding that inlining copies code at every call, increasing binary size.

#2 Expecting lambdas inside inline functions to never create objects.

Wrong approach:

inline fun foo(action: () -> Unit) {
val localLambda = { println("Hi") }
action()
localLambda()
}

Correct approach:

inline fun foo(action: () -> Unit) {
action()
}

// Pass lambdas directly to avoid extra objects

Root cause:

Confusing lambdas passed as parameters (inlined) with lambdas created inside function bodies (not inlined).

#3 Trying to use reified types in non-inline functions.

Wrong approach:

fun checkType(value: Any) = value is T // Error: reified requires inline

Correct approach:

inline fun checkType(value: Any) = value is T

Root cause:

Not knowing that reified types need inline functions to keep type info at runtime.

Key Takeaways

Inline functions replace function calls with actual code to reduce call overhead and improve speed.

They are especially useful with lambdas to avoid creating extra objects and reduce memory use.

Inlining can increase the size of the compiled code, so use it carefully to balance speed and size.

Reified type parameters only work with inline functions, enabling powerful type checks at runtime.

Understanding when and how to use inline functions is key to writing efficient Kotlin programs.