Re: When/why did function calls get cheap?

> They don't call -- they jump. The fancy thing about CPS is that you
> get rid of some special cases: you don't have to handle things
> differently for tail calls and ordinary calls (in principle) because
> both are just parameter passing andjumps. You also don't have to
> handle both a stack and a heap -- you can easily make do with only a
> heap (SML/NJ does that).


It makes sense however to make the heap able to do at least limited
LIFO allocation, instead of relying completely on the garbage
collector. GNU Smalltalk has heap-allocated activation records
(coupled with continuation passing when using the just-in-time
compiler), but the heap is not the same heap where other objects are
allocated: instead it is special in that if an activation record and
all of its children create no closure, then it can be quickly
deallocated.


I find that around 90% of the activation records can be GCed this way.


(Actually this is not strictly related to continuation-passing, but to
every implementation of heap-allocated activation records. These are
an extraordinarily expensive way to do function calls, just to keep in
topic with the subject of the message...)


Paolo

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