Memory warning and crash (ARC) – how to identify why it's happening?

I’ve started to use the ARC recently and since then I blame it for every single memory problem. 🙂 Perhaps, you could help me better understand what I’m doing wrong.

My current project is about CoreGraphics a lot – charts drawing, views filled with thumbnails and so on. I believe there would be no problem while using manual memory management, except maybe a few zombies… But as of now, application simply crashes every time I try to either create a lot of thumbnails or redraw a bit more complicated chart.

  • Iphone convert color image to 2bit image (black-white)
  • Does cocos2d support ARC?
  • Is it possible to alter the letter-spacing/kerning of a font with Cocoa Touch?
  • Animated CAShapeLayer Pie
  • How do you load a local jpeg or png image file into an iPhone app?
  • Creating UIImage from NSData created from buffer returns nil?
  • While profiling with Instruments I can see an awfully high value in resident memory as well as in the dirty one. Heap analysis shows rather alarming irregular grow…

    When drawing just a few thumbnails, resident memory grows for about 200 MB. When everything is drawn, memory drops back on almost the same value as before drawing. However, with a lot of thumbnails, a value in resident memory is higher than 400 MB and that obviously crashes the app. I’ve tried to limit number of thumbnails drawn at the same time (NSOperationQueue and its maxConcurrentOperationCount), but as releasing so much memory seems to take a bit more time, it didn’t really solve the issue.

    Right now my app basically doesn’t work as the real data works with a lot of complicated charts = lot of thumbnails.

    Every thumbnail is created with this code I got from around here: (category on UIImage)

    + (void)beginImageContextWithSize:(CGSize)size
        if ([[UIScreen mainScreen] respondsToSelector:@selector(scale)]) {
            if ([[UIScreen mainScreen] scale] == 2.0) {
                UIGraphicsBeginImageContextWithOptions(size, YES, 2.0);
            } else {
        } else {
    + (void)endImageContext
    + (UIImage*)imageFromView:(UIView*)view
        [self beginImageContextWithSize:[view bounds].size];
        BOOL hidden = [view isHidden];
        [view setHidden:NO];
        [[view layer] renderInContext:UIGraphicsGetCurrentContext()];
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        [self endImageContext];
        [view setHidden:hidden];
        return image;
    + (UIImage*)imageFromView:(UIView*)view scaledToSize:(CGSize)newSize
        UIImage *image = [self imageFromView:view];
        if ([view bounds].size.width != newSize.width ||
            [view bounds].size.height != newSize.height) {
            image = [self imageWithImage:image scaledToSize:newSize];
        return image;
    + (UIImage*)imageWithImage:(UIImage*)image scaledToSize:(CGSize)newSize
        [self beginImageContextWithSize:newSize];
        [image drawInRect:CGRectMake(0,0,newSize.width,newSize.height)];
        UIImage *newImage = UIGraphicsGetImageFromCurrentImageContext();
        [self endImageContext];
        return newImage;

    Is there some other way which wouldn’t eat so much memory or is something really wrong with the code when using ARC?

    The other place where memory warning + crash is happening is when there is too much redrawing of any view. It doesn’t need to be quick, just many times. Memory stacks up until it crashes and I’m not able to find anything really responsible for it. (I can see a growing resident/dirty memory in VM Tracker and a heap growth in Allocations instrument)

    My question basically is: how to find why it is even happening? My understanding is when there is no owner for given object, it’s released ASAP. My inspection of code suggests a lot of objects are not released at all even though I don’t see any reason for it to happen. I don’t know about any retain cycles…

    I’ve read through the Transitioning to ARC Release Notes, bbum’s article about heap analysis and probably a dozen of others. Differs somehow heap analysis with and without ARC? I can’t seem to do anything useful with its output.

    Thank you for any ideas.

    UPDATE: (to not force everybody read all the comments and to hold my promise)

    By carefully getting through my code and adding @autoreleasepool, where it had any sense, memory consumption got lowered. The biggest problem was calling UIGraphicsBeginImageContext from background thread. After fixing it (see @Tammo Freese’s answer for details) deallocation occurred soon enough to not crash an app.

    My second crash (caused by many redrawing of the same chart), was completely solved by adding CGContextFlush(context) at the end of my drawing method. Shame on me.

    A small warning for anyone trying to do something similar: use OpenGL. CoreGraphics is not quick enough for animating big drawings, especially not on an iPad 3. (first one with retina)

    3 Solutions Collect From Internet About “Memory warning and crash (ARC) – how to identify why it's happening?”

    To answer your question: Identifying problems with memory warnings and crashes with ARC basically works like before with manual retain-release (MRR). ARC uses retain, release and autorelease just like MRR, it only inserts the calls for you, and has some optimizations in place that should even lower the memory consumption in some cases.

    Regarding your problem:

    In the screenshot of Instruments you posted, there are allocation spikes visible. In most cases I encountered so far, these spikes were caused by autoreleased objects hanging around too long.

    1. You mentioned that you use NSOperationQueue. If you override -[NSOperationQueue main], make sure that you wrap the whole content of the method in @autoreleasepool { ... }. An autorelease pool may already be in place, but it is not guaranteed (and even if there is one, it may be around for longer than you think).

    2. If 1. has not helped and you have a loop that processes the images, wrap the inner part of the loop in @autoreleasepool { ... } so that temporary objects are cleaned up immediately.

    3. You mentioned that you use NSOperationQueue. Since iOS 4, drawing to a graphics context in UIKit is thread-safe, but if the documentation is right, UIGraphicsBeginImageContext should still only be called on the main thread! Update: The docs now state that since iOS 4, the function can be called from any thread, to the following is actually unnecessary! To be on the safe side, create the context with CGBitmapContextCreate and retrieve the image with CGBitmapContextCreateImage. Something along these lines:

      CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
      CGContextRef context = CGBitmapContextCreate(NULL, width, height, 8, 0, colorSpace, kCGImageAlphaPremultipliedLast);
      // draw to the context here
      CGImageRef newCGImage = CGBitmapContextCreateImage(context);
      UIImage *result = [UIImage imageWithCGImage:newCGImage scale:scale orientation: UIImageOrientationUp];
      return result;

    So, nothing you are doing relative to memory management (there is none!) looks improper. However, you mention using NSOperationQueue. Those UIGraphics… calls are marked as not thread safe, but others have stated they are as of iOS 4 (I cannot find a definitive answer to this, but recall that this is true.

    In any case, you should not be calling these class methods from multiple threads. You could create a serial dispatch queue and feed all the work through that to insure single threaded usage.

    What’s missing here of course is what you do with the images after using them. Its possible you are retaining them in some way that is not obvious. Here are some tricks:

    • in any of your classes that use lots of images, add a dealloc() method that just logs its name and some identifier.

    • you can try to add a dealloc to UIImage to do the same.

    • try to drive your app using the simplest possible setup – fewest images etc – so you can verify that in fact that the images and their owners are getting dealloc’d.

    • when you want to make sure something is released, set the ivar or property to nil

    I converted a 100 file project to ARC last summer and it worked perfectly out of the box. I have converted several open source projects to ARC as well with only one problem when I improperly used bridging. The technology is rock solid.

    This is not an answer to your question but I was trying to solve similar problems long before ARC was introduced.
    Recently I was working on an application that was caching images in memory and releasing them all after receiving memory warning. This worked fine as long as I was using the application at a normal speed (no crazy tapping). But when I started to generate a lot of events and many images started to load, the application did not manage to get the memory warning and it was crashing.

    I once wrote a test application that was creating many autoreleased objects after tapping a button. I was able to tap faster (and create objects) than the OS managed to release the memory. The memory was slowly increasing so after a significant time or simply using bigger objects I would surely crash the application and cause device to reboot (looks really effective ;)). I checked that using Instruments which unfortunately affected the test and made everything slower but I suppose this is true also when not using Instruments.

    On the other occasion I was working on a bigger project that is quite complex and has a lot of UI created from code. It also has a lot of string processing and nobody cared to use release – there were few thousands of autorelease calls when I checked last time. So after 5 minutes of slightly extensive usage of this application, it was crashing and rebooting the device.

    If I’m correct then the OS/logic that is responsible for actually deallocating memory is not fast enough or has not high enough priority to save an application from crashing when a lot of memory operations are performed. I never confirmed these suspicions and I don’t know how to solve this problem other than simply reducing allocated memory.