🚀 go-pugleaf

Alan L. Lovejoy (alovejoy@concentric.net) wrote:
: Tom Payne wrote:
: > 
: > Alan L. Lovejoy (alovejoy@concentric.net) wrote:
: > :
: > : I did those benchmars to prove that Smalltalk message sends are faster
: > : than c function calls.  To do that, I needed a benchmark that consisted
: > 
: > How is that possible, given that the message has to find the entry
: > point of the method and has to communicate parameters by mechanisms
: > not unavailable to C.
: 
: It's a fact.  It's possible because full method lookup only needs to
: occur the first time a message is sent to a receiver of a particular
: class, not each time a message is sent--and because message sends do not
: use "JSR/BSR" machine instructions, but just use simple jumps or 
: branches.  Remember, method contexts are allocated on the heap, not on
: the stack.  

This shows that a particular implementation of Smalltalk message sends
is faster than a particular implementation of C function calls, which
is both surprising and interesting, but does not show message sends to
be inherently faster.  (Perhaps, all you are claiming is the relative
performance in a particular case.)

As I recall, the standard trick for eliminating most of the overhead
of method lookups on message sends is to cache the method on each send
and next time check for correctness.  Of course, this correctness
check is overhead that is unnecessary in C.  The fact that in this
implementation method contexts are allocate on the heap, not the
stack, leaves me even more puzzled; heap allocation is no faster, in
fact almost always slower, than stack allocation, which merely
involves incrementing a pointer.

Tom Payne (thp@cs.ucr.edu)