Re: When/why did function calls get cheap?

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. But then, somewhere along the way, the compiler
> writers got clever and made function calls cheap so now nobody worries
> about it.


In addition to speed, changes in computer architecture have
also had their effect:


1) Instruction cache misses are very expensive, so if you 'inline'
        either manually or automatically too much code and blow out the
        i-cache the program may run slower than if the program
        used functions to share code.


2) Branch prediction coupled with speculative execution, out of order
        execution and register renaming can effectively make a lot of
        the boiler-plate function-call work/instructions cheap compared
        to an i-cache miss or branch predition failure.


3) Branch prediction works best on repeated code sequences and
        static targets (for example function calls).
        The branch prediction unit has a finite size
        and must 'guess' the first time it sees a branch. This can
        be a problem for excessive inlining. Also, failed branch
        preditions are expensive on deeply pipelined architectures.
        A failed branch prediction can even exacerbate the i-cache problem
        since the instruction prefetch will not be able to hide the memory
        latency.


In other words, the cost model for modern computers is different
than it was 25 years ago as well. Locality (cachability) and
predictability are more important than pure instruction counts.

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