Efficiency of accessing a value through a pointer vs storing as temporary value

Question

If there's function that takes a pointer to struct as parameter and the function has a loop that access a member at every iteration like:

int function_a(struct b *b)
{
    // ... do something then
    for(int i = 0; i < 500; ++i){
        b->c->d[i] = value();
    }
}

Is it going to retrieve the location c points to and d points to from memory every time?

Now consider the following situation:

int function_a(struct b *b)
{
    // ... do something then
    float *f = b->c->d;
    for(int i = 0; i < 500; ++i){
        f[i] = value();
    }
}

Would that be faster?

Answer 1

I urge you to heed Thomas Matthews' advice regarding profiling, however to answer your question: it depends.

This particular transformation is also known as code hoisting which consists in moving code without side-effect and with the same result at each call outside of a loop. As noted though, this is only performed if the compiler can prove:

• that there is no side-effect
• that the same result is computed at each call

In both cases, this basically means that the compiler should have access to the full code (see the definitions) of both:

• the expression itself, to prove the absence of side-effect
• anything that might alter something about the expression, to prove that the same result is computed each time

Therefore, it is actually unlikely that it will perform the optimization unless all the code for the body loop is included in the headers (and thus can be inlined) because any opaque function could hide a modification of b->c (for example) through an evil global variable.

In your example, nothing proves that value() does not change b->c... so no, the compiler would be wrong to hoist the code unless it has access to the definition of value() and can rule this possibility out.

Answer 2

Using a temporary may not be faster than accessing a temporary: depends on the platform.

When in doubt, look at the assembly language generated by the compiler. On the ARM processor, when accessing the memory:

• A register is loaded with the address of the variable.
• The register is dereferenced to obtain the value (and stored in another register).

This is very similar to dereferencing a pointer:

• A register is loaded with the pointer value.
• The register is dereferenced to obtain the value.

There may be a second load from memory to fetch the pointer value. The truth is in the assembly language.

This is known as a micro-optimization and should only be applied as a last resort to speed up code in performance critical areas. Use a profiler to find out where the bottlenecks are and address those first.