c++ - what is faster ?

Question

If we have the following 2 snippets of code in c++ that do the same task:

int a, b=somenumber;
while(b > 0)
{
a = b % 3;
b /= 3;
}

or

int b=somenumber;
while(b > 0)
{
int a=b%3;
b /= 3;
}

I don't know much about computer architecture/c++ design, but i think that the first code is faster because it declares the integer a at the beginning and just uses it in the while-loop, and in the second code the integer a is being declared everytime the while-loop starts over. Can some one help me with this, am i correct or what and why ?

Answer 1

The first one SHOULD be faster; however the compiler is usually smart enough to optimise this itself so probably won't matter.

For purities sake though, the answer is the first one

EDIT: It is faster because it requires only one allocation as opposed to N (N being the number of iterations the while loop will perform).

Answer 2

No, it can't be "declared" in the loop, as it is declared at compile-time. I'd say they're equal, but the second one might have been faster if the type of the variable was something more complicated, having constructor and destructor.

Answer 3

The int declaration is information for the compiler and does not translate to an instruction that has to be coded. So it makes no difference. Declaring the int inside the loop will not slop the loop down. Why not try compiling both for yourself and get the compiler to output assembly code so you can see for yourself.

Answer 4

Seriously, does it really matter ? This is the type of the micro-optimizations you should try to avoid. Write the code which is more readable which IMHO is the second loop. The compiler is good enough to do the optimization for these type of things and I would leave it to do that.

Answer 5

There is no "faster" in the C++ standard, except for performance guarantees in the standard library. An optimizing compiler would likely just eliminate a, since it's not used. Alternately, it could allocate all the memory the function needed for all local variables at once, and then it wouldn't make any difference either.

The only legitimate question about low-level language constructs like this is whether your particular implementation runs them faster or slower, and the best way to find it out is to time it yourself. You'll find that a whole lot of these things simply don't matter, and if you examine the generated code you'll often find that compilers do the same thing with different ways of writing code.

Usually, looking for micro-optimizations is a bad idea, but if you're trying to set up a general style it may be worth it (using ++i rather than i++, for example). However, if you're setting up a style for any purpose other than readability, you should have good reasons for doing it. In this case, that means testing for performance.

Answer 6

Theoretically the first option might be faster. In practice I'd expect a and b to be put into registers in such a way that the generated assembly comes out identical (which you can verify in the compiled binary). If you're executing the loop enough times that you think there may be a difference, the only way to know is to measure. If your profiler can't tell a different, code it in the way that makes the code the clearest to future maintainers.

In general (as already mentioned) these types of optimizations won't provide any sort of meaningful improvement in program performance. You should instead look for algorithmic and design optimizations.

Answer 7

Generally speaking it is better to pre-allocate variables you want to use. As your second example is re-allocating the variable everytime. Still, the compiler should generate near equivliant assembly code in the above situations, since the example is so trivial (only using an integer). If you were constructing an object everytime in the loop there could be significant penalty.

That said, it is important to realize that in your first example a and b will be accesible outside the while loop, while in your second example they will not be. This is a functional difference that needs to be considered when writing loops in this manner.

Answer 8

There should be no difference, but to be extra empirical (anal?) I tested this with g++, creating a function for each of the code snippets. Both with and without optimizations it generated identical code no matter where the int a declaration is.

#include <iostream>

int variant_a(int b)
{
        int a;
        while(b > 0)
        {
                a = b % 3;
                b /= 3;
        }
        return b;
}

int variant_b(int b)
{
        while(b > 0)
        {
                int a = b % 3;
                b /= 3;
        }
        return b;
}

int main()
{
        std::cout << variant_a(42) << std::endl;
        std::cout << variant_b(42) << std::endl;
}

This is the unoptimized loop:

_Z9variant_ai:
.LFB952:
        pushl   %ebp
.LCFI0:
        movl    %esp, %ebp
.LCFI1:
        subl    $24, %esp
.LCFI2:
        jmp     .L2
.L3:
        movl    8(%ebp), %eax
        movl    %eax, -20(%ebp)
        movl    $1431655766, -24(%ebp)
        movl    -24(%ebp), %eax
        imull   -20(%ebp)
        movl    %edx, %ecx
        movl    -20(%ebp), %eax
        sarl    $31, %eax
        subl    %eax, %ecx
        movl    %ecx, %eax
        addl    %eax, %eax
        addl    %ecx, %eax
        movl    -20(%ebp), %edx
        subl    %eax, %edx
        movl    %edx, %eax
        movl    %eax, -4(%ebp)
        movl    8(%ebp), %eax
        movl    %eax, -20(%ebp)
        movl    $1431655766, -24(%ebp)
        movl    -24(%ebp), %eax
        imull   -20(%ebp)
        movl    %edx, %ecx
        movl    -20(%ebp), %eax
        sarl    $31, %eax
        movl    %ecx, %edx
        subl    %eax, %edx
        movl    %edx, %eax
        movl    %eax, 8(%ebp)
.L2:
        cmpl    $0, 8(%ebp)
        jg      .L3
        movl    8(%ebp), %eax
        leave
        ret

and the optimized one:

_Z9variant_ai:
.LFB968:
        pushl   %ebp
.LCFI0:
        movl    %esp, %ebp
.LCFI1:
        pushl   %ebx
.LCFI2:
        movl    8(%ebp), %ebx
        testl   %ebx, %ebx
        jle     .L2
        movl    $1431655766, %ecx
        .p2align 4,,7
        .p2align 3
.L5:
        movl    %ebx, %eax
        imull   %ecx
        movl    %ebx, %eax
        sarl    $31, %eax
        movl    %edx, %ebx
        subl    %eax, %ebx
        jne     .L5
.L2:
        movl    %ebx, %eax
        popl    %ebx
        popl    %ebp
        ret

Answer 9

I don't believe there would be any difference in practice. There are no memory allocations involved, because the memory for automatic variables is allocated or set aside at compile time.

Theoretically I think the second could easily be faster as well: the compiler has more information about where and how the variables are used (e.g may-be you reuse the same variable for something completely unrelated later).

You might start to worry about such things when you are dealing with types that are expensive to construct. E.g should I declare a std::vector in the inner loop, or should I declare it before the loop and clear() it at the beginning of the loop body (reusing the allocated memory).