Optimizing Data Caching for iPhone Application Responsiveness

Fake It ’Til You Make It:
Tips and Tricks for Improving
Interface Responsiveness
Jonathan Saggau (@jonmarimba)
Sounds broken inc

The dude

I am keenly interested in iPhone application responsiveness.

I’m not here to hurt any feelings... but I’m passionate about this and I might get a little excited.

As a freelance iPhone developer primarily writing applications that connect to database or HTTP servers, I have had a lot of
opportunity to watch my ﬁrst stabs at cloud-based applications seem abysmally slow to respond to user input because the app is
busy downloading or parsing data.
Since a lot of my time is spent talking to servers, I have amassed a fair number of tricks to make applications seem faster than
they really are, from prefetching data to caching to drawing to off-screen contexts in separate threads. I am excited to share
some of those tricks with you.
A lot of applications I work on allow users to bring their own data. This keeps one on one’s toes...

“Speed is money. How much do you want to spend?”

- Old auto racing adage

Why do some native applications seem so fast while others do not? There is an old adage in auto racing. “Speed is money. How
much do you want to spend?” It doesn’t take long for iPhone programmers to rub up against a similar problem, one perhaps
expressed as,

“Speed is developer time. How much do you have left to
spend before release?”

Recall the keynote: "Good cooking takes time. If you are made to wait, it is to
serve you better, and to please you."

“Speed is time. How much do you have left to spend before release?” Given the limitations of processor power, RAM, and network
bandwidth, not to mention battery drain, writing iPhone applications that display lots of data is hard. Clever caching, prefetching
of data, and optimized drawing are the keys to removing the variable response times that make an app that’s consuming
nonlocal or large amounts of data seem slow to the user.

“Speed is developer time. How much do you have left to
spend before release?”

Recall the keynote: "Good cooking takes time. If you are made to wait, it is to
serve you better, and to please you."

Yup. This is the car my
dad bought. 2009
Ford Shelby GT-500.
He is, so far, still with
us.

“Speed is time. How much do you have left to spend before release?” Given the limitations of processor power, RAM, and network
bandwidth, not to mention battery drain, writing iPhone applications that display lots of data is hard. Clever caching, prefetching
of data, and optimized drawing are the keys to removing the variable response times that make an app that’s consuming
nonlocal or large amounts of data seem slow to the user.

TAKE THE TIME TO DO THE COOKING. (I drove this car and it scared the hell out of me)

“death by 1,000 paper cuts”

Displaying Large Amounts of Data Efﬁciently

How can you avoid a “death by 1,000 paper cuts” user experience when you have a lot of data to display? Most of the
applications that Apple ships on the iPhone access network services, and many of them deal with large data sets. Mail pulls and
caches potentially large amounts of data from your mail server, the Maps application loads tiles from Google Maps, and the
Weather application requests the latest weather on demand; even the Calendar and Contacts applications can sync with data
stored on servers hosted by Microsoft, Google, Yahoo, and Apple. Many well-reviewed third-party applications also pull large
quantities of data from the cloud in one way or another. Facebook, Pandora, AIM, Yahoo Instant Messenger, and many others
have developed offerings that are robust and responsive. Writing an application for the iPhone that displays large amounts of
potentially nonlocal data is not easy. You’ve probably experienced an application that seems to start and stop working
depending on your network connection or how much information you’ve loaded. Users of native iPhone applications have
different expectations with regard to interface responsiveness than they do when browsing the Web. It’s difficult to satisfy a user
who tolerates multiple page loads while using a browser but who may not tolerate a slow-scrolling table view or a view that takes
a few seconds to download data and render in a native application.

The inspiration

One of my clients has an application that pulls potentially dozens of high-resolution images from a database server into an
image-browsing view not unlike that of Apple’s Photos application. To load something into the image viewer quickly, we prefetch
a set of low-resolution thumbnail images from the database and scale them to fit the screen. As the user thumbs through the
images, the application downloads the current high-resolution image and those to the left and right thereof. As each large image
arrives, the application replaces the low-resolution image on screen with the high-resolution image. For the application to
remain responsive, image decoding and drawing are handled in a background thread by pushing the images to off-screen
CGContextRefs.

Also see a lot of applications that abuse UIWebView. It seems that there are a lot of developers writing applications that show
pdf or word files who just load them into UIWebView. That’s okay if you’re controlling content, but if you allow the user to
choose files to view, as in our upcoming application gogoDocs, you’re going to get yourself into trouble. UIWebView is not
designed for big content. It just falls down when you load a large pdf into it. I can’t tell you how many apps I have used and
dumped because it can’t handle my content. grr.

The inspiration
(UIWebView is teh suck)

CGContextRefs.


The inspiration
(UIWebView is teh suck*)

*Actually, it’s pretty cool. It just doesn’t always stand up under heavy usage.

CGContextRefs.


The inspiration
(UIWebView is teh suck*)

CGContextRefs.


Demo project:
BigViewThing.app

To solve a similar problem as that of my client and my own project, we’ll examine a project for drawing a vertical succession of
very large images into a zoomable scroll view. So that you might encounter some of the difficulties inherent in dealing with large
amounts of data, you’ll add an admittedly somewhat contrived requirement: the images cannot be presliced, thumbnailed, or
otherwise massaged outside of the device. All drawing code must use the original 1600x1200 large PNG images shown in Figure
9-12 bundled with the application. If you can make this example perform reasonably well, you’ll have a reusable framework for
drawing any processor-intensive tiled scroll view while maintaining UI responsiveness.

Derived from this sweet sample code from WWDC
scrollview session:

http://developer.apple.com/iphone/library/samplecode/
ScrollViewSuite/index.html

You’ll begin with a modiﬁed version of Apple’s ScrollViewSuite sample code available at http://developer.apple.com/iphone/
library/samplecode/
ScrollViewSuite/index.html called BigViewThing. The original Apple sample is designed to draw view tiles that are chunks of a
larger image; it shows how to reuse view objects in two dimensions similar to the way the UITableView dequeues and enqueues
rows in one dimension. In the case of Apple’s sample, the smaller image chunks are meant to ship with the application.
BigViewThing is already partially implemented as a result of being derived from this sample code. It handles double-tap to zoom,
suspends tile redraws when the user is interacting with the view, and draws only on-screen tiles. It’s in the Examples/
06BigViewThingOriginal directory of the sample code. Build it and run. There are quite a number of large images in it, so it will
take a while to copy over to the device.

Demo
or... Julia Child impression

Build and run. Show how damn slow. Show Shark proﬁle.

Demo
or... Julia Child impression

This might stink.
I swear that’s on purpose.

Build and run. Show how damn slow. Show Shark proﬁle.

!

I’m doing everything the dumbass slow way.

As you can see in Figure 9-13, almost all the application’s execution time is being used in decompressing and drawing the PNG
images. Our goal with this demonstration application is to simulate what happens when drawing very heavy, data-intensive
views. You never know when a user is going to try to load a giant document or image into your application.

This is a simulation of “what happens when I have to do a lot of stuff to get my view to draw,” not an exercise in optimizing
image drawing.

Drawing UI in a background thread.

!


Danger, Will Robinson! UIKit is not thread-safe. Try to draw to
screen from another thread, and bad things might happen. Ugly
things are almost guaranteed to happen.You can, however, draw
your images into off-screen buffers (cgContexts work here) and
then grab the pixels that you need to throw on the screen once
the buffer is ﬁlled with data. There is nothing stopping you from
ﬁlling that data asynchronously and reading it from the main thread
in order to draw it.


1. The ﬁrst time one of the BigViewPageView objects is asked to
draw, it will create a cgContext into which it will quickly draw a half
opaque white background as a placeholder when the
BigViewPageView is inactive.


II. It will draw whatever is currently in the off-screen context to the
screen in drawRect:


III. It will generate an NSOperation that will ﬁll a new cgContext in a
background thread with the image data as it is needed.


IV. When the NSOperation ﬁnishes, it will swap the new buffer in and
call setNeedsDisplay on the view in the main thread so the view
knows to draw the image data to screen. Drawing from a buffer is
fast(er).

V. Any time the BigViewPageView is asked to drawRect, it pulls the
image data from the current cgContext for drawing; it’s also ﬁlling
new cgContexts in the background if you change the expected
drawing size of the image through some bizarre action like zooming.
Before the new buffer is ready, your image will stretch to ﬁll and
probably pixelate for a moment while the NSOperation is preparing
new data much like UIWebView.

NSOperation and NSOperationQueue

NSOperationQueue and NSOperation remove much of the pain of
multithreading. NSOperationQueue is a sort of thread pool that
maintains an array of pending NSOperation objects that it schedules
to run in a background thread based on a number of factors from
system hardware to system state to the relative priority of a given
NSOperation.

NSOperationQueue and NSOperation remove much of the pain of multithreading. NSOperationQueue is a sort of thread pool that
maintains an array of pending NSOperation objects that it schedules to run in a background thread based on a number of factors
from system hardware to system state to the relative priority of a given NSOperation. You can even declare one NSOperation
dependent on the completion of another. You normally subclass NSOperation to override one method, main, which is where you
put the work you want on a background thread. It’s called when the operation is run.

Playing with ^{blocks()}

Landon Fuller’s Plausible Blocks
http://code.google.com/p/plblocks/

“Cause it’s gonna be the future soon. And I won't always be this way. When the things that
make me weak and strange get engineered away.”
—Lyrics for The Future Soon by Jonathan Coulton

There is a helpful tool in other languages for this kind of problem
called blocks. Blocks are another name for closures, with which you
may have familiarity with from using Ruby, LISP, Python, Smalltalk,
and others. They’re like function pointers that take a (usually const)
snapshot of their local stack variables so you can run them later with
the information you shove in them now. They’re little portable units of
computation that carry their state around and are extraordinarily
useful with concurrent operations. Because they have a snapshot of
their state, they’re easier to deal with in a concurrent environment.

Patched Compiler Plugin For Xcode
and a runtime

!

Demo

Add Blocks runtime and compiler. Walk through new drawing code that uses blocks and background drawing.

First, download the latest disk image of the Plausible Blocks compiler and frameworks from http://code.google.com/p/plblocks/
downloads/list. Mount the disk image, and run the included package. This installs the patched compiler as an Xcode plug-in.
Now copy the iPhone Runtime folder, which includes the static framework you’ll need to link against, into the StockPlot project.
Double-click the StockPlot target, select the General tab, and click the plus (+) button in the lower-left corner of the window to
add a new linked library. Click Add Other in the resulting sheet, and navigate to and select the framework for addition, as shown
in Figure 9-9.
Now you need to tell Xcode to use the special compiler. Double-click the StockPlot target to open the Build Settings window.
Select the Build tab. Select All Conﬁgurations from the upper-left drop-down. Now select the GCC 4.2 (Plausible Blocks)
compiler, as shown in Figure 9-10. You now have blocks support.

I’m doing everything the dumbass slow way.
In a background thread.
So you can still use the app.

As you can see in Figure 9-13, almost all the application’s execution time is being used in decompressing and drawing the PNG
images. Our goal with this demonstration application is to simulate what happens when drawing very heavy, data-intensive
views. You never know when a user is going to try to load a giant document or image into your application.

This is a simulation of “what happens when I have to do a lot of stuff to get my view to draw,” not an exercise in optimizing
image drawing.

UIScrollView Zooming
Content
Offset Images Get Stretched
(affine xform)

ContentView
UIScrollView !

One thing that UIWebView performs very well is its sharp redrawing of zoomed content after a zoom is finished. In BigViewThing,
you’re currently allowing the scroll view to zoom for you and leaving the content alone when zooming is finished. This default
behavior results in an unpleasant grainy appearance because the UIScrollView that you use to host the content simply applies a
scaling affine transform to the content view. It’s also expanding or contracting its own content size relative to the new drawn
size of the overall view. UIScrollView does this for performance reasons. If it takes three seconds (and it does take that long right
now in our application) to draw a view into a given square of pixels, imagine what it might look like to animate resizing by
redrawing. One-third of a frame per second is subpar to say the least.
Search the Internet for UIScrollView zooming reset resolution, and you’ll find a lot of developers pulling their hair out trying to
get this to look right. A little caveman NSLog experimentation to figure out what the UIScrollView is really doing can reveal what’s
happening under the covers when you, say, pinch to zoom or directly set the zoomScale property of a UIScrollView.

As the zoom scale changes, the UIScrollView does two things:
by default

1. It sets an affine transform on the view it is zooming to scale it up or down
without redrawing. It’s a “square” transform that maintains aspect ratio, so there
is no distortion.

2. It resets its own contentSize, contentOffset, and zoomScale so as to hold the
content in place relative to the point about which it is zooming (in the case of
pinching, that point was halfway between your fingers).

If the zoom was performed with a pinch gesture or through the setZoomScale:animated: methods, it calls
scrollViewDidEndZooming:withView:atScale: on its delegate when the zooming ends. However, it does not call this delegate
method if the animated: argument was NO because the zoom is set instantly when you call the method. The UIScrollView
assumes that you know that it finishes zooming right away in that case. After zooming, the UIScrollView leaves the affine
transform on the view, and it leaves the stretched contentSize, contentOffset, and zoomScale in place, which is why the view
seems grainy. It’s still being stretched when you zoom.

Resetting Resolution in a UIScrollView after a Zoom
Operation

Operation

Not coincidentally, it’s 12 steps

Operation

1. Take a snapshot of the current (scaled)
contentSize and contentOffset.

Operation

2. Take a snapshot of the current (unscaled)
content view’s frame size; it’s being scaled by an
afﬁne transform, so its actual frame size is the
same as it was before zooming.

Operation

3. Take a snapshot of the current minimum and
maximum zoom scales.

Operation
4. If your scroll view is its own delegate as it is in
BigViewThing, call super to set the minimum and
maximum zoom scales both to 1.0 because setting
zoom on self will eventually call updateResolution
again; inﬁnite recursion is so last year.

Operation
4. If your scroll view is its own delegate as it is in
BigViewThing, call super to set the minimum and
maximum zoom scales both to 1.0 because setting
zoom on self will eventually call updateResolution
again; inﬁnite recursion is so last year.
5. Set the current zoom scale to 1.0, which will
rescale the content size internally back to the size
of the content view, and reset the afﬁne transform
on the content view to unity.

Operation
5. Set the current zoom scale to 1.0, which will
rescale the content size internally back to the size
of the content view, and reset the afﬁne transform
on the content view to unity.
6. Calculate new content offset by scaling the stretched/
zoomed offset you took a snapshot of in step 1. You want
the new content to appear in the same place in the scroll
view:

Operation
6. Calculate new content offset by scaling the stretched/
zoomed offset you took a snapshot of in step 1. You want
the new content to appear in the same place in the scroll
view:
7. newContentOffset.x *= (oldContentSize.width /
contentViewSize.width);
8. newContentOffset.y *= (oldContentSize.height /
contentViewSize.height);

Operation
7. newContentOffset.x *= (oldContentSize.width /
contentViewSize.width);
8. newContentOffset.y *= (oldContentSize.height /
contentViewSize.height);
9. Divide the old minimum and maximum zoomScale by
the new zoom scale. This scales the original minimum and
maximum zooms relative to the new content size. If
minimum zoom were 1.0 and maximum zoom were 2.0,
when the user zooms to 2.0 and I reset, my new minimum
zoom would be .5, and my new maximum zoom would be
1.0.

Operation
9. Divide the old minimum and maximum zoomScale by
the new zoom scale. This scales the original minimum and
maximum zooms relative to the new content size. If
minimum zoom were 1.0 and maximum zoom were 2.0,
when the user zooms to 2.0 and I reset, my new minimum
zoom would be .5, and my new maximum zoom would be
1.0.

10. Set the content view’s frame.size to the contentSize
you took a snapshot of in step 1.

This is a little counterintuitive. The numeric values of the new content size are being reset to the same values as those the scroll
view calculated for the transformed zoomed view but are now reinterpreted in a new overall scroll view frame. Essentially, Apple
already did the math for you, so you’re reusing its values in a new context.

Operation

11. Set the scroll view’s contentSize to the scaled
contentSize you took a snapshot of in step 1. This stretches
the overall size of the view to match the new zoom level
(but without any afﬁne transform applied).

Operation

11. Set the scroll view’s contentSize to the scaled
contentSize you took a snapshot of in step 1. This stretches
the overall size of the view to match the new zoom level
(but without any afﬁne transform applied).

12. Call the setNeedsLayout method on the scroll view.
This will cause layoutSubviews to be called where you can
reset the content view’s internal subview geometry.

Because you just did a bunch of changes to the geometry of the
content view, your subviews, in this case: the pictures, are gonna be
all weird and in the wrong place because you haven’t laid them out.
LayoutSubviews is where that happens and calling setNeedsLayout will
make the layoutSubviews get called soon.

Demo

Zooming code addition. Show the zooming code step by step. Show that it seems to get slower and slower.

Why do it this way?

It’s the only way I know that always works. It redraws at the right time
(when the user is not trying to do anything).

NSOperation Cancellation
In a category on NSOperationQueue:

- (void)cancelOperationsFilteredByPredicate:(NSPredicate *)predicate;
{
NSArray *ops = [[self operations]
filteredArrayUsingPredicate:predicate];
for (NSOperation *op in ops)
{
if(![op isExecuting] && ![op isFinished] && ![op isCancelled])
{
[op cancel];
}
}
}

Every time I zoom in or zoom out on an image, the view pushes another NSOperation onto the queue. If you insert log messages
printing the contents of the NSOperationQueue at some regular interval, you will see that there are an ever-growing number of
operations for each view getting pushed when there is a lot of zooming going on. This makes the app seem like it’s updating
less and less often or even getting sometimes more pixellated. The queue eventually clears but not after drawing a given image
several times, usually at zoom levels not currently needed for drawing.

Wouldn’t it be nice to be able to cancel only certain pending operations on the NSOperationQueue? You can. You just call the
cancel method on your NSOperation object; the queue will eventually (but not immediately) remove it, but it will never actually
run it. You can add a weak reference to the NSOperation subclass to point back to the BigViewPageView object that placed it on
the queue and then ask each NSOperation that belongs to you to cancel before you add another operation to the queue. This
way, you can be sure that there is little wasted CPU time.

If you notice that the NSOperation objects stay in the queue for a while, that is OK. When NSOperationQueue decides that it is
time to run a given operation, it will call start on the NSOperation and wait for that operation to finish executing. If isCancelled
returns YES, the NSOperation will tell the NSOperationQueue that it is finished right away without ever calling the main method.
Add the operation cancellation code into your BigViewPageView:

You can ﬁnd more information on NSPredicate in Apple’s
Predicate Programming Guide available at http://
developer.apple.com/mac/library/documentation/Cocoa/
Conceptual/Predicates/Articles/pUsing.html.

NSpredicate is an extraordinarily useful class that uses key-value coding to perform queries on objects. I tend to think of them
as structured queries for Cocoa objects, often used to ﬁlter arrays based on some parameter or parameters of the objects it
contains. Cocoa programmers have enjoyed NSPredicate’s power for some time, but it has only recently come to the iPhone in
the 3.0 SDK. It’s also an important part of the magic of Core Data.

Caching tradeoffs

• Staleness (cached data is old data)
• User interface responsiveness (cached
data is faster data)
• Memory usage (cached data takes up
space somewhere)

Different types of iPhone apps
require different strategies
• Where does your data live?
• On-disk read-only
• On-disk read-write
• Client-server read-only
• Client-server read-write

Data Request Overhead
• On-disk

• Cloud data

• How much data is optimal per request?

• Parsing and memory overhead (why
NSXMLDocument doesn't exist on the iPhone)

• Limited memory workspace - working in chunks

• How to distribute pauses in UI responsiveness as a
result of requesting data to avoid giving the
appearance of a "slow" application

If it might take a while (you did use Shark, right?)...

Stay off the main thread. Please.

NOTE Apple has not officially announced any intention to bring
blocks to the iPhone, though it’s a fair bet that Apple will do so once
blocks are added to the desktop runtime and compiler collection. You
should very thoroughly test any application using a nonstandard
compiler and be prepared for things to break in spectacular and
unexpected ways. That said, Plausible Blocks appears well on its way
to release-level stability.

Further Reading
http://github.com/landonf/block_samples/tree/master
http://www.mikeash.com/?page=pyblog/friday-
qa-2008-12-26.html
http://cocoasamurai.blogspot.com/2009/09/guide-to-blocks-
grand-central-dispatch.html
http://macresearch.org/cocoa-scientists-part-xxvii-getting-
closure-objective-c
http://developer.apple.com/Cocoa/
managingconcurrency.html.

These additions to the Objective-C language and runtime are free and open source, and they’ve been
implemented in GCC 4.2, so it is actually quite possible to backport them to the iPhone, so of course they have
been. Plausible Blocks from Plausible Labs is available at http://code.google.com/
p/plblocks/ and is, as of this writing, shipping its second beta of a gingerly patched version of the standard,
stable GCC 4.2 compiler that ships with the OS X Leopard (10.5) and iPhone software development kits. I have
found it to be very stable, and it works with both iPhone OS 3.0 and 2.2.1 targets. There is some example
code for their use on the primary author’s GitHub repository available at http://github.com/landonf/
block_samples/tree/master. Next you’ll install the Plausible Blocks compiler and add its static framework to
your project so you can easily place your downloading, parsing, and saving code in a block to be executed by
an NSOperation to be scheduled by an NSOperationQueue (in the house that Jack built). All of the things that
make your application weak and strange are being gradually engineered away, and you’re even using future
technology!

bignerdranch.com

jonathan@jonathansaggau.com
http://jonathansaggau.com/blog
twit: @jonmarimba

QC: http://360idev.mobclix.com/

Look for gogoDocs. Coming soon
to an app store in your pocket.

If you’re a Google docs user, we’re
looking for testers.

twit: @jonmarimba

QC: m.360idev.com

Will Code for food.

twit: @jonmarimba

Nerds for hire // Hiring nerds // Working with Big Nerds

Recommended Reading
http://github.com/landonf/block_samples/tree/master
http://www.mikeash.com/?page=pyblog/friday-
qa-2008-12-26.html
http://cocoasamurai.blogspot.com/2009/09/guide-to-blocks-
grand-central-dispatch.html
http://macresearch.org/cocoa-scientists-part-xxvii-getting-
closure-objective-c
http://developer.apple.com/Cocoa/
managingconcurrency.html.

These additions to the Objective-C language and runtime are free and open source, and they’ve been
implemented in GCC 4.2, so it is actually quite possible to backport them to the iPhone, so of course they have
been. Plausible Blocks from Plausible Labs is available at http://code.google.com/
p/plblocks/ and is, as of this writing, shipping its second beta of a gingerly patched version of the standard,
stable GCC 4.2 compiler that ships with the OS X Leopard (10.5) and iPhone software development kits. I have
found it to be very stable, and it works with both iPhone OS 3.0 and 2.2.1 targets. There is some example
code for their use on the primary author’s GitHub repository available at http://github.com/landonf/
block_samples/tree/master. Next you’ll install the Plausible Blocks compiler and add its static framework to
your project so you can easily place your downloading, parsing, and saving code in a block to be executed by
an NSOperation to be scheduled by an NSOperationQueue (in the house that Jack built). All of the things that
make your application weak and strange are being gradually engineered away, and you’re even using future
technology!

Next up...
Meed, um, me.
Apress authors gonna be right over there >

Optimizing Data Caching for iPhone Application Responsiveness

More Related Content

What's hot (20)

Similar to Optimizing Data Caching for iPhone Application Responsiveness (20)

More from John Wilker (20)

Recently uploaded (20)

Optimizing Data Caching for iPhone Application Responsiveness