function overhead?

Hey all,

I'm just wondering about the amount of overhead a function incurs?

More specifically, I'm writing some 3D related code that makes use of several functions which perform very basic operations on vectors (3D vectors, not the C++ templates) which are basically just an array of 3 floats.
One such function would be adding two vectors, ie.

Code:

---

void addVect(float *dst, float *v1, float *v2) {
  dst[0] = v1[0] + v2[0];
  dst[1] = v1[1] + v2[1];
  dst[2] = v1[2] + v2[2];
}

---

Since these operations will be carried out a great deal, I'm wondering if anyone has any insights on the overhead incurred by using a function, as opposed to a macro for this.

I plan on doing some benchmarks to find out anyway, but I wouldn't mind knowing some more about what's going on, and why.

If you have a decent compiler, the overhead might be "nothing", as the compiler may well optimize out the entire function call and just inline the actual calculation.

If you haven't got a decent compiler, then the suggestion would be to get one.

gcc 3.x and Visual Studio 2005/2008 are both great compilers.

--
Mats

Thanks matsp,

I did some benchmarking, and, in VS2005 there was no overhead, so, I'm guessing it just inlined the code.

I also tried it with Borland 5 in which case there was significant overhead. The functionalized algorithms took 4-7 times longer than the macros.

Note in C99 or C++ you can force it to be inline -- with the inline keyword.

Quote:

---

Originally Posted by zacs7

Note in C99 or C++ you can force it to be inline -- with the inline keyword.

---

No, you can't FORCE an inline with the inline keyword. It is just a suggestion to the compiler that it should inline the function - older compilers are more likely to take note of this, modern (e.g. gcc 3+) will inline functions by itself, without any such requests, if it thinks it's the right thing to do.

Some compilers (e.g. MS) has a "forceinline" keyword that will put more stress on the "I want this inlined", but it's still possible that the compiler decides for some reason that it's not going to inline something.

--
Mats

That's what I meant :)

> I'm wondering if anyone has any insights on the overhead incurred by using a function,
Compile the function, and look at the assembler. How many instructions are actually implementing your code, and how many are just there to make it easy to call the function.

Typically, I count (in approximate cost terms)
- each parameter as being the same as a simple assignment.
- the call itself as two simple assignments (fetch the address is 1, the broken pipeline is the other).
- the function prologue and epilogue each as a simple assignment (create/destroy stack frame)
- the return and clean up the stack again as 2 simple assignments.

Your example on an X86 would be pretty horrid to call as a function. Although you're indexing arrays, the x86 has indexing instructions which mean x[const] is efficiently encoded.

On the other hand, the RISC machine I was using some time ago passed the first 4 params in registers, and did away with the whole stack frame bit if the function was a leaf function (one which doesn't call anything else).

> I also tried it with Borland 5 in which case there was significant overhead.
Debug or release?
Debug is "do what I ask", Release is "do what I mean" kinda thing.

Also, prior to C99, C lacked the 'inline' keyword, but that doesn't mean to say that all compilers ignore it. Even without it, look for compiler options which might indicate 'inline short functions'.

Making the function 'static' can also help, to give the compiler the hint that nothing outside the module can call it.

Thanks for all the info.

Anyone know of an easy way to view the ASM that's generated for a function? I haven't used ASM much, so I don't know the best tools and stuff for it. I don't suppose there's just an easy way to do this is VS2k5? :)

Quote:

---

Originally Posted by Tox|k

Thanks for all the info.

Anyone know of an easy way to view the ASM that's generated for a function? I haven't used ASM much, so I don't know the best tools and stuff for it. I don't suppose there's just an easy way to do this is VS2k5? :)

---

You can pop an assembly window from the debugger...

Or go to your project/file properties in the project view and set "listing" to "Assembler + Source" (I think that's /FAs if you use command line code generation).

Welcome to the world of "Studying compiler output".
--
Mats

With VS200X, all you need to do is press Alt+8 to see the assembly while debugging.