Memory Optimization Techniques for Image-Intensive iOS Applications

In many iOS apps, especially those that handle a large number of images, memory consumption can become a critical issue. This article, authored by Tencent terminal development engineer Zhang Hengming, discusses why memory optimization is necessary, analyzes the causes, and presents practical solutions.

1. Necessity of Memory Optimization

Even though modern iPhones have increasing RAM, excessive memory usage can still lead to app crashes, forced termination (FOOM), and increased power consumption due to the system’s Memory Compressor.

2. FOOM (Forced Out‑Of‑Memory)

When the system’s available memory is insufficient, the OS may kill the app process. FOOM is harder to detect and debug than a normal crash.

3. Limiting Concurrency

High‑memory tasks reduce the number of concurrent operations an app can perform, and may cause the OS to kill other apps to free memory.

4. Increased Power Consumption

Memory pressure triggers the Memory Compressor, which writes dirty pages to disk and later reads them back, increasing CPU load and battery drain.

Reason Analysis

1. Image Display Principle

An image consists of pixels stored in an Image Buffer . Compressed formats (JPEG, PNG) must be decoded before rendering, expanding the data to raw pixel bytes.

2. Real Memory Usage of an Image

For a 1920×1080 image in SRGB (4 bytes per pixel): 1920 * 1080 * 4 = 829440 bytes This equals roughly 7.9 MB after decoding, regardless of the original file size.

Solution Strategies

1. Avoid Keeping Unused Images in Memory

Do not decode or retain UIImage objects for images that are not currently displayed.

2. Image Scaling

Traditional scaling using UIGraphicsBeginImageContextWithOptions can be memory‑intensive. Example:

extension UIImage {
    public func scaling(to size: CGSize) -> UIImage? {
        let drawScale = self.scale
        UIGraphicsBeginImageContextWithOptions(size, false, drawScale)
        let drawRect: CGRect = CGRect(origin: .zero, size: size)
        draw(in: drawRect)
        let result = UIGraphicsGetImageFromCurrentImageContext()
        UIGraphicsEndImageContext()
        return result
    }
}

A better approach uses UIGraphicsImageRenderer, which automatically selects an appropriate color format:

extension UIImage {
    func scaling(to size: CGSize) -> UIImage? {
        let renderer = UIGraphicsImageRenderer(bounds: CGRect(origin: .zero, size: size))
        return renderer.image { context in
            self.draw(in: context.format.bounds)
        }
    }
}

While this reduces color‑format waste, it does not eliminate the memory peak caused by full decoding.

3. Reducing Memory Peaks

Use autorelease pools to release temporary objects after each iteration:

for image in images {
    autoreleasepool {
        operation()
    }
}

For large batch processing, employ streaming APIs such as ImageIO to create thumbnails without caching the full image:

func resizedCgImage(url: URL, for size: CGSize) -> CGImage? {
    let options: [CFString: Any] = [
        kCGImageSourceShouldCache: false,
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceCreateThumbnailWithTransform: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceThumbnailMaxPixelSize: max(size.width, size.height)
    ]
    guard let imageSource = CGImageSourceCreateWithURL(url as NSURL, nil),
          let image = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, options as CFDictionary) else {
        return nil
    }
    return image
}

4. Cropping to the Display Area

When only a portion of an image is shown (e.g., a 300×300 view displaying a 1920×1080 image), loading a full‑size image wastes memory. Downsampling to the view size reduces memory usage dramatically:

func downsample(imageAt imageURL: URL, to pointSize: CGSize, scale: CGFloat) -> UIImage {
    let imageSourceOptions = [kCGImageSourceShouldCache: false] as CFDictionary
    let imageSource = CGImageSourceCreateWithURL(imageURL as CFURL, imageSourceOptions)!
    let maxDimensionInPixels = max(pointSize.width, pointSize.height) * scale
    let downsampleOptions = [
        kCGImageSourceCreateThumbnailFromImageAlways: true,
        kCGImageSourceShouldCacheImmediately: true,
        kCGImageSourceCreateThumbnailWithTransform: true,
        kCGImageSourceThumbnailMaxPixelSize: maxDimensionInPixels
    ] as CFDictionary
    let downsampledImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, downsampleOptions)!
    return UIImage(cgImage: downsampledImage)
}

Effect Comparison

Before optimization, using UIGraphicsBeginImageContextWithOptions caused memory peaks up to 600 MB. After applying the above techniques, peak memory dropped to about 221 MB (≈36 % of the original).

References

iOS Memory Deep Dive – WWDC 2018 (https://developer.apple.com/videos/play/wwdc2018/416)

Image and Graphics Best Practices – WWDC 2018 (https://developer.apple.com/videos/play/wwdc2018/219)