inline functions

Question

Possible Duplicate:
Benefits of inline functions in C++?

I have a confusion regarding the inline function.

People say inline functions saves CPU time by replacing the function with the original code, but that it increases the size of the code when compared to a normal function.

So the real question is if I keep on calling that inline function within a loop for 10 times, will the code size get increased.

Suppose the inline function size is 2 bytes, will it increase by 20 bytes?

Can anyone explain it to me?

Answer 1

The same code will be executed 10 times. But still within a loop, so the code is not copied 10 times in a row. So size will not grow with the number of executions.

Answer 2

I don't know why you'd think the number of loop iterations would matter. Let's see. Suppose you write this:

inline int foo() { return 5 * gargle(); }

/* later... */

for (size_t i = 0; i < 100; ++i)
{
  const int x = i * foo();
  baz(x + lookup[i]);
}

If foo gets inlined, then essentially the compiler treats your code as though you had written:

for (size_t i = 0; i < 100; ++i)
{
  baz(i * (5 * gargle()) + lookup[i]);
}

So the code only gets replaced at the call site, once.

(It's a separate matter entirely whether loop unrolling is happening.)

Answer 3

It totally depends on you, your code, and your compiler. Imagine you have:

#include <vector>

int frob (int a, int b) {
    return a + b;
}

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; ++i) {
        results[i] = frob(lhs[i], rhs[i]);
    }
}

Now if your compiler optimizes for size, it might leave this as is. But if it optimizes for performance, it may (or may not, some compilers use rough heuristic measures to determine that) transform this to:

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; ++i) {
        results[i] = lhs[i] + rhs[i];
    }
}

If it optimizes even more, it might unroll the loop

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; i+=4) {
        results[i] = lhs[i] + rhs[i];
        results[i+1] = lhs[i+1] + rhs[i+1];
        results[i+2] = lhs[i+2] + rhs[i+2];
        results[i+3] = lhs[i+3] + rhs[i+3];
    }
}

Size increased. But if the compiler now decides to also to a bit of auto vectorization, it might transform again into a something not unsimilar to this:

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);
    for (int i=0; i<20; i+=4) {
        vec4_add (&results[i], &lhs[i], &rhs[i]);            
    }
}

Size decreased.

Next on, the compiler, smart as always, unrolls again and kills the loop entirely:

int main () {
    std::vector<int> results(20), lhs(20), rhs(20);

    vec4_add (&results[i], &lhs[i], &rhs[i]);            
    vec4_add (&results[i+4], &lhs[i+4], &rhs[i+4]);
    vec4_add (&results[i+8], &lhs[i+8], &rhs[i+8]);
    vec4_add (&results[i+12], &lhs[i+12], &rhs[i+12]);
    vec4_add (&results[i+16], &lhs[i+16], &rhs[i+16]);
}

An optimization g++ will exercise if it can conclude enough is to replace a vector with an ordinary array

int main () {
    int results[20] = {0}, lhs[20] = {0}, rhs[20] = {0};

    vec4_add (&results[i], &lhs[i], &rhs[i]);            
    vec4_add (&results[i+4], &lhs[i+4], &rhs[i+4]);
    vec4_add (&results[i+8], &lhs[i+8], &rhs[i+8]);
    vec4_add (&results[i+12], &lhs[i+12], &rhs[i+12]);
    vec4_add (&results[i+16], &lhs[i+16], &rhs[i+16]);
}

It sees how everything is constant, and folds

int main () {
    int results[20] = {0}; // because every lhs[0]+rhs[0] == 0
}

It concludes that results is actually unused, and finally spits out:

int main() {
}

Answer 4

When you use inline, you are telling the compiler to replace any calls to your inline method, with the code from that method. For example:

inline int min(int a, int b)
{
    return (a < b) ? a : b;
}

void some_method()
{
    int x = min(20, 30);
}

would be changed by the compiler to:

void some_method()
{
    int x = (20 < 30) ? 20 : 30;
}

If this was in a loop, it would still be just the one replacement, so it wouldn't increase code size in that particular situation.

That said, there are Problems With Inline Functions that should be considered. Frequently, letting the compiler decide what to inline will be more efficient than doing it yourself.

Answer 5

Using the inline keyword give the compiler permission to inline function calls, which opportunity it may or may not take up.

The reason that this might make the program quicker is that the CPU won't have to make a function call, and won't have to push parameters onto the stack, so in fact the compiler might be able to generate much less code at the call site than when it performs a function call.

Additionally the optimiser might be able to re-order/eliminate instructions that are now closer together to give even better performance and even less code.

The only way to know if this happens is trial and error. You write it one way and measure performance and code size, and then write it the other way and test again.