How can I optimise the declaration of a function that always returns the same value for a given run?

Question

I have an objective-c class method, which for a given launch of the application will always return the same value; I remember reading somewhere that I could declare a function in such a way that the compiler would understand this and make appropriate optimisations.

(It may have had something to do with the static keyword, but I can't remember, and Google only tells me "they're not static methods, they're class methods", which isn't what I'm talking about at all.)

My specific situation—though the question applies to any function or method—is a category on UIColor, which returns application-specific colour values in a similar way to [UIColor redColor] et. al. While these colours may be customised per device and may change from one run to the next, they will always be the same value for each run of the application.

While I'm also interested in whether there's particular value in any such optimisations, I'm far more interested in the actual declaration. I'm happy to hear if I'm "doing it wrong," but I'd also like to hear how I can actually declare a function or method in this manner.

UPDATE: It has nothing to do with static; sorry, that was irrelevant.

Answer 1

You can use a static variable. Its value will be preserved across function calls, so if you never modify it, it will store the same value during the entire lifetime of your program. Something like this:

- (UIColor *)beautifulColor
{
    static UIColor *color = nil;

    if (color == nil) {
        color = [ColorFactory randomColor];
    }

    return color;
}

Answer 2

I think you're thinking of "inlining", which is where the compiler replaces a function call with the body of the function, which avoids the minor overhead of the call.

The GCC docs say that this will happen for "simple enough" functions, presumably including a constant function like the one you're talking about.

This doesn't apply to ObjC methods, though. No method can be inlined, because of dynamic dispatch. When you write [queequeg castHarpoon];, you're just sending a message, not directly calling a method the way fabs() is a function call. queequeg might or might not actually run the method named castHarpoon. 98% of the time, that's what happens, but the object has the option, at runtime, to decide to run some other method. That means the compiler can't inline the message send with a method body.

Answer 3

A way to do this is to have a shared preferences object, usually a singleton, where the init functions does this lookup or calculation, and then stores it in a property.

After that point, methods needing that information would use the property. If the property is non-atomic, it should have small overhead.

If you want to avoid all overhead, declare either a static or a global variable, as in C, and set it up during startup. Not that anyone really recommends globals. Eew. :)

Answer 4

I found it! The answer was, of course, on NSHipster and relates to the __attribute__ directive.

In my particular case, the const specifier seems to fit best:

The const attribute specifies that a function does not examine any values except their arguments, and have no effects except the return value. Note that a function that has pointer arguments and examines the data pointed to must not be declared const. Likewise, a function that calls a non-const function usually must not be const.

So I was going to declare my class method as:

+ (UIColor *)primaryTintColor __attribute__((const));

After adding the __attribute__ directive as above, the code compiled without error and behaves as expected under Xcode 5.0.2 and the iOS SDK 7.0.

But as others have pointed out in the comments below, methods resolve internally to a function that includes a pointer argument to resolve self, so __attribute__((const)) is never appropriate for methods. In this case, while it's a simple call to +[UIColor colorWithRed:green:blue:alpha:] I'll leave it as it is, but when it gets more complex—say, to slightly customise the values for different devices—I may well use a static variable to cache the value and use performance profiling to quantify any improvement.