Re: When/why did function calls get cheap?

On 12 Feb 2003, Peter Seibel wrote:


> My understanding is that in Olden Times, Real Programmers avoided
> using lots of small functions because the overhead of a function call
> was considered high.


> the actual work--are there deep black-magic optimizations or did the
> relative costs of something change or something else entirely?


Small functions are usually leaf functions which mean they are easier
to inline. It is also easier to get away with simpler parameter
passing and call/return stuff.


Example:


Many RISCs don't have a call instruction that pushes a return address
onto the stack. They have a specialized jump instruction that stores
the address of the instruction following the call into a register.
Non-leaf procedures would then store that register value someplace
else while they made their own calls. Leaf functions don't have to.
So, less (or no) stack manipulation for leaf functions. The idea of
separating registers into callee-save and caller-save + passing
parameters in registers also helped immensely.


The implementations of the ISAs has also improved: many provide an
internal, hidden return stack so all calls and returns are correctly
predicted (unless you try to play tricks and don't match them up).
Some also provide forwarding paths for the typical stores to
memory/reads from memory used for parameter passing and for the
spill/load code necessary on register starved ISAs (IA-32).


And there are the caches. If you call small functions instead of
inlining them, you reduce your icache pressure. Inlining is usually
only a good idea if it enables other optimizations on the code in the
body of the inlined function (strength reduction, cse, dead code
elimination).


-Peter

Return to the comp.compilers page.
Search the comp.compilers archives again.