For a function like this, does it make sense to make it inline?

public inline fun Boolean.asGBoolean(): Int = if (this) 1 else 0

I think (!), this is useless because the JVM will inline this at runtime

also when it's running on Kotlin/Native (which is the target)

I guess this is only useful if the kotlin compiler/llvm is able to do constant folding after data flow analysis and the resulting inlining. Otherwise, I don't think this is worth it. Keep in mind, llvm also optimizes the resulting kotlin code, so best thing is testing.

Thank you for the explanation, I'll add it to my experiment list

Please don't call it an explanation, but a guess.

I’ll often inline performance-critical methods that often get called repeatedly just to indicate to a future programmer what my intention is.

For Kotlin/Native optimization questions, you can take a look at https://godbolt.org/noscript/kotlin Keep in mind though that things like this can change between versions.

This seems to use the JVM compiler, not the K/N compiler.

I was sure the compiler explorer had Kotlin Native 🤔

They closed the PR, since they weren’t quite happy with the results. https://github.com/compiler-explorer/compiler-explorer/pull/2738

in any case, I think adding

inline

is a terrible way to express the intention of "cheap function". it increases your compile time by inflating the intermediate IR, and excessive inlining leads to code bloat which causes worse performance due to icache misses. best leave it to the compiler or PGO to determine what makes sense to inline.

I’m not quite sure I’ve always trusted the compiler to optimize inline, since there’s a tradeoff of space vs speed. I have a method in one project where I know from benchmarks that if it becomes an actual function, there’s too much overhead, and I see a performance difference (this method is on all the the hottest parts of the loop). The compiler may decide to not inline it to save on space, but in this case, I want each instance to be inlined.

inlining can win at microbenchmarks while losing on overall application performance

This was before we had microbenchmarks. Our benchmarks were all running the program and automatically checking a few performance metrics.

for context: The use case for this particular function is basically every wrapped method that returns a native boolean, and needs to be converted to a Kotlin Boolean for my generated bindings

in that case I think it would be better to have it inlined into your generated code instead of having a

inline fun

which becomes part of your ABI (unless you really want it to be)

I usually inline that, since there’s no way that method takes up more space than a function call, but the compiler may catch it.

true, and that's actually the simplest solution