Faster "release" build from Xcode?

Question

I am relatively new to Xcode. We are testing an app that displays incoming data and it needs to be as fast as possible. With other platforms I need to change from "debug" to "release" in order for optimizations to kick in and debug code to be removed, which can have a profound effect on speed. What are the equivalent things I need to do in Xcode to build in fast/release mode?

(I am googling this and see lots of hits that seem to be in the general vicinity but I might be a little thrown off by the terminology, I might need it dumbed down a bit :))

Thanks for the help.

Answer 1

The first step is to set the Optimization Level for release as described above. There are lots of options here. From the clang LLVM compiler man page (man cc) -- (note that -Os is the default for Release):

   Code Generation Options
   -O0 -O1 -O2 -O3 -Ofast -Os -Oz -O -O4
       Specify which optimization level to use:

       -O0 Means "no optimization": this level compiles the fastest and
           generates the most debuggable code.

       -O1 Somewhere between -O0 and -O2.

       -O2 Moderate level of optimization which enables most
           optimizations.

       -O3 Like -O2, except that it enables optimizations that take longer
           to perform or that may generate larger code (in an attempt to
           make the program run faster).

       -Ofast
           Enables all the optimizations from -O3 along with other
           aggressive optimizations that may violate strict compliance
           with language standards.

       -Os Like -O2 with extra optimizations to reduce code size.

       -Oz Like -Os (and thus -O2), but reduces code size further.

       -O  Equivalent to -O2.

       -O4 and higher
           Currently equivalent to -O3

You will notice the 'Ofast' option -- very fast, somewhat risky.

A second step is to consider whether to enable "Unroll Loops". I've read that this can in some code lead to a 15% speed increase (at the expense of debugging, but not an issue for Release builds).

Next, consider whether you want to Build and use an Optimization Profile. See Apple for details, but the gist is that:

Profile Guided Optimization (PGO) is a means to improve compiler optimization of an app. PGO utilizes a specially instrumented build of the app to generate profile information about the most commonly used code paths and methods. The compiler then uses this profile information to focus optimization efforts on the most frequently used code, taking advantage of the extra information about how the program typically behaves to do a better job of optimization.

You define the profile and whether you use it under Build Settings -> Apple LLVM 6.0 - Code Generation -> Use Optimization Profile.

Answer 2

First have a look at this part in Xcode (screenshot of Xcode 5 but same on Xcode 6)

You should also prefer PNG to Jpeg (as Jpeg requires more calculation - but are generally smaller in terms of size so better for network...) Finally, Use multi-threading. Those are (to mu humble opinion) the first steps to look at.