What’s the point of `reinterpret<T>()`-ing a...

# kotlin-native

[natario1]

What’s the point of reinterpret<T>()-ing a pointer, instead of simple (unchecked) casting? I thought the function performs checks based on the new T type, but looking at source code, it’s not even inline/reified. I don’t think the runtime receives the type information. So what kind of safety does reinterpret() provide?

And related, is there any case were unchecked cast is legitimate? Maybe when size/align won’t change?

[damian]

Seems that it calls interpretCPointer which is annotated with TypedIntrinsic, suggesting that it's implemented as a compiler intrinsic. I don't know the answer to your question though

[ephemient]

reinterpret provides zero safety. the point is to bypass any other checks that e.g. as would normally provide

[natario1]

I feel more confused now 😄 so it’s about performance? I imagine that the unchecked cast from CPointer<A> to CPointer<B> would have almost zero cost, it’s even the same type. On the other hand the interpret call creates a new CPointer instance and has a !!.

[Joakim Forslund]

.reinterpret() is just a forced typecast into the expected type, no safety. Nothing more

[natario1]

I understand, thanks. It seems more expensive than as though, in which case, why is it not implemented as as under the hood?

[ephemient]

I'm not sure why you think that

[ephemient]

val y = x.reinterpret<T>() doesn't return a new instance, it is like val y = x except that Kotlin now treats that part of memory as type T whether that is correct or not

[natario1]

It’s what the source code suggests, see https://github.com/JetBrains/kotlin/blob/7a7d392b3470b38d42f80c896b7270678d0f95c3/[…]ative/Interop/Runtime/src/main/kotlin/kotlinx/cinterop/Types.kt . interpretCPointer takes this.rawValue (not this) and returns a CPointer. Of course there might be compiler/runtime magic under the hood

[Joakim Forslund]

Its literally just a pointer of 8 bytes, in runtime it will map that to given type, there is no different penalty

[natario1]

From the tests below, reinterpret is 6 times slower than casting on my machine. I’m not calling these a benchmark, I don’t have a lot of time to waste on this… but unless something new pops up in this thread, I think I’ll def spend some time removing reinterpret() from critical parts of my codebase.

class PointerTests {
    @Test
    fun testInterpretPointer() {
        memScoped {
            var intPtr: CPointer<IntVar> = alloc<IntVar>().ptr
            var longPtr: CPointer<LongVar> = alloc<LongVar>().ptr
            measureTime {
                repeat(200000) {
                    longPtr = intPtr.reinterpret()
                    intPtr = longPtr.reinterpret()
                }
            }.also {
                println("testInterpretPointer: $it")
            }
        }
    }

    @Test
    fun testCastPointer() {
        memScoped {
            var intPtr: CPointer<IntVar> = alloc<IntVar>().ptr
            var longPtr: CPointer<LongVar> = alloc<LongVar>().ptr
            measureTime {
                repeat(200000) {
                    intPtr = longPtr as CPointer<IntVar>
                    longPtr = intPtr as CPointer<LongVar>
                }
            }.also {
                println("testCastPointer: $it")
            }
        }
    }
}

[Edoardo Luppi]

So reinterpret is unsafeCast in K/JS?

[Edoardo Luppi]

If it is, sounds like a good ticket to align the two, makes it easier to switch platform

[ephemient]

not quite, reinterpret only works between native pointer types

[Edoardo Luppi]

Oh then it's a bit different yeah, unsafeCast is an extension function on Any