Allocating a temporary variable or compute the expression twice [duplicate]

Question

I am trying to write a code as efficient as possible and I encountered the following situation:

int foo(int a, int b, int c) 
{
    return (a + b) % c; 
}

All good! But what if I want to check if the result of the expression to be different of a constant lets say myConst. Lets say I can afford a temporary variable.

What method is the fastest of the following:

int foo(int a, int b, int c) 
{
    return (((a + b) % c) != myConst) ? (a + b) % c : myException; 
} 

or

int foo(int a, int b, int c) 
{
    int tmp = (a + b) % c
    return (tmp != myConst) ? tmp : myException; 
}

I can't decide. Where is the 'line' where recalculation is more expensive than allocating and deallocating a temporary variable or the other way around.

Answer 1

Don't worry about it, write concise code and leave micro-optimizations to the compiler.

In your example writing the same calculation twice is error prone - so do not do this. In your specific example, compiler is more than likely to avoid creating a temporary on the stack at all!

Your example can (does on my compiler) produce following assembly (i have replaced myConst with constexpr 42 and myException with 0):

foo(int, int, int):
        leal    (%rdi,%rsi), %eax       # this adds a and b, puts result to eax
        movl    %edx, %ecx      # loads c
        cltd
        idivl   %ecx  # performs division, puts result into edx
        movl    $0, %eax        #, prepares to return exception value
        cmpl    $42, %edx       #, compares result of division with magic const
        cmovne  %edx, %eax  # overwrites pessimized exception if all is cool
        ret

As you see, there is no temporary anywhere in sight!

Answer 2

Use the later.

1. You're not computing the same value twice.
2. The code is more clear.
3. Creating local variables on the stack doesn't take any significant amount of time.