Reduce the amount of time to release 1 million + objects while popping out VC

Question

The current iOS app that we have has to download more than a million objects from the server and we keep it in an array for certain purposes. When the user is done with this functionality and the app takes a while to go back to the previous screen (~15 sec) Its because the 1 million objects are being released. We can see from Instruments that the count going from 1 million to 0 during this time (15 sec). Is there any way to speed up the deallocation of these 1 mn objects that are there in the array?

Answer 1

Instead of trying to dealloc these objects faster, I would recommend that you dealloc them slower.

1. Keep all these objects somewhere else. Create some singleton [ObjectsManager sharedInstance], which will be responsible for downloading and holding all these objects in some NSMutableArray.
2. Use these objects whenever you want in other VCs.
3. When you are finished, tell your [[ObjectsManager sharedInstance] removeAllDownloadedObjects], which would slowly remove all of them from your NSMutableArray.
4. Instead of writing [myArray removeAllObjects], do it part by part -- delete 20000 objects every second, using NSOperation or GCD.

Answer 2

I freed 1 milion instances of ~600 MB (picked expensive UIView) in somewhere about one and half of sec on iPhone 6s. When tried with modest class (~50 MB), it took ~0.2 sec. Still, if you can hold your data in struct, you are going close to zero. I believe, you are losing your time somewhere else...

import UIKit

@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?

    class C: UIView {
        static var c = 0
        deinit { C.c -= 1 }
        init() { C.c += 1; super.init(frame: CGRect.zero) }
        required init?(coder aDecoder: NSCoder) { fatalError() }
    }

    func application(application: UIApplication, didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {

        var a: [C]? = []
        for i in 0..<1_000_000 {
            a!.insert(C(), atIndex: i)
        }

        print(C.c) // We have 1_000_000 allocations.

        let t1 = CFAbsoluteTimeGetCurrent()
        a = nil
        let t2 = CFAbsoluteTimeGetCurrent()

        print(t2 - t1) // 1 milion instances of ~600 MB freed in ~1.5 seconds.
        print(C.c) // ARC works!

        return true
    }
}

Answer 3

The problem is heap fragmentation. Deallocating a contiguous block of memory in language like ie ObjC/C/C++ etc is fast. Deallocating fragmented memory in comparison is slow. It's hard to test because the allocation and deallocation pattern quite often effects the amount of fragmentation you see. An example might help.

A lot of allocators use mixed sized bins of linked lists to allocate from. When you allocate a million of these in a loop you're likely to have a a lot of contiguous pieces of memory which when deallocated in a loop takes advantage of the caches etc ie it looks fast. When you test it in production it's not so fast.

The only way to avoid it is to avoid Heap fragmentation and that means..

1. Allocate blocks that hold N objects and deallocate each block in one go.
2. Ideally allocate one contiguous memory region for the entire set of N objects and deallocate it in one call.