I have problems with a memory leak when sending objects from a kotlin framework to an objective c cl...

# kotlin-native

[David]

I have problems with a memory leak when sending objects from a kotlin framework to an objective c class. Basically, once the object has been sent to objective c it is never released. Have I done anything stupid or is this a bug? I will put the code in the thread, but the full project is available here:
https://github.com/dtornqvist/LeakingProblem

[David]

KotlinNativeFramework.kt:

class KotlinNativeFramework {
    var listener: KotlinNativeFrameworkListener? = null

    fun giveMeDoubles() {
        while (true) {
            val myList = DoubleArray(100) { 1.0 }.toList()
            listener?.listenToDoubles(myList) // If this line is commented, the leak stops.
        }
    }
}

interface KotlinNativeFrameworkListener {
    fun listenToDoubles(list: List<Double>)
}

LeakingClass.m:

#import "LeakingClass.h"

@interface LeakingClass()

@property (nonatomic, strong) KNFKotlinNativeFramework *knf;

@end


@implementation LeakingClass

-(void)start
{
    _knf = [KNFKotlinNativeFramework new];
    self.knf.listener = self;
    [self.knf giveMeDoubles];
}

- (void)listenToDoublesList:(NSArray<KNFDouble *> *)list {}

@end

[svyatoslav.scherbina]

self.knf.listener = self

Isn’t it a retain cycle?

[David]

Maybe it is, but the main problem is that each list of doubles is leaking.

[David]

Memory usage goes to infinity quite rapidly. If I comment the call to the listener, it is stable.

[svyatoslav.scherbina]

This is highly likely caused by not having autorelease pool for listenToDoubles. When calling from Kotlin to Objective-C, Kotlin runtime creates temp Objective-C NSArray wrapper for Kotlin List.

[svyatoslav.scherbina]

So your code should look like

fun giveMeDoubles() {
        while (true) {
            val myList = DoubleArray(100) { 1.0 }.toList()
            autoreleasepool {
                listener?.listenToDoubles(myList) // If this line is commented, the leak stops.
            }
        }
    }

[David]

Thanks, that works! How to avoid the retain cycle you commented on? Is it possible to have weak references in kotlin native?

[svyatoslav.scherbina]

Yes, it is possible: http://kotlinlang.org/api/latest/jvm/stdlib/kotlin.native.ref/-weak-reference/index.html

[David]

Thanks!

[svyatoslav.scherbina]

You are welcome!

[David]

@Svyatoslav Kuzmich [JB] It seems that running the autoreleasepool lambda is quite slow. My kotlin class is event-driven and does all work on a Worker. As events is coming in at a rate of 25-50Hz it is not possible to use the autoreleasepool-lambda at every callback to the listener. I have then manually created my pool when creating the Worker with pool = objc_autoreleasePoolPush() and then I periodically call objc_autoreleasePoolPop(pool). Is this best practice or is there another way?

[olonho]

@svyatoslav.scherbina ^^^

[svyatoslav.scherbina]

Do I understand correctly that you create your pool only once?

[David]

Yes

[svyatoslav.scherbina]

This doesn’t look correct to me.

[svyatoslav.scherbina]

As far as I know, every Objective-C autorelease pool must be popped only once.

[David]

Ok, it doesn’t seem to crash and I don’t see the memory explosion that I had before. So, the best way perhaps is to avoid sending lists to objective-c? If the conversion between lists and NSArrays is the problem…

[svyatoslav.scherbina]

If I’m correct, then the proper way would be to replace the entire pool periodically, i.e.

objc_autoreleasePoolPop(pool)
pool = objc_autoreleasePoolPush()

[David]

Ok, I see your point! It is nice when this is done for you… 🙂

[svyatoslav.scherbina]

So, the best way perhaps is to avoid sending lists to objective-c? If the conversion between lists and NSArrays is the problem…

No. Normal Objective-C code uses autorelease pools too. So the necessity to release the pool periodically doesn’t seem to be specific for Kotlin/Native

[David]

Ok, thanks! Not sure why the normal ARC doesn’t take care of it though…

[svyatoslav.scherbina]

Btw, you still can use autoreleasepool {} without falling back to its implementation details `objc_autoreleasePoolPop`/`objc_autoreleasePoolPush` with something like this:

while (true) {
            autoreleasepool {
                repeat(autoreleaseFrequency) {
                    val myList = DoubleArray(100) { 1.0 }.toList()
                    listener?.listenToDoubles(myList)
                }
            }
        }

[David]

Thanks, but in the real code my class i called with data and I call Worker.execute to perform work and do the callback. It is then not possible to wrap several event-cycles in one lambda.