Optimizing simple calls in a dynamically typed language?

=?ISO-8859-1?Q?Christoffer_Lern=F6?= <lerno@dragonascendant.com>
Sat, 23 Aug 2008 13:38:06 -0700 (PDT)

          From comp.compilers

Related articles
Optimizing simple calls in a dynamically typed language? lerno@dragonascendant.com (=?ISO-8859-1?Q?Christoffer_Lern=F6?=) (2008-08-23)
Re: Optimizing simple calls in a dynamically typed language? oliverhunt@gmail.com (oliverhunt@gmail.com) (2008-08-24)
Re: Optimizing simple calls in a dynamically typed language? gene.ressler@gmail.com (Gene) (2008-08-24)
Re: Optimizing simple calls in a dynamically typed language? chris.morley@lineone.net (Chris Morley) (2008-08-25)
Re: Optimizing simple calls in a dynamically typed language? pkhuong@gmail.com (Paul Khuong) (2008-08-25)
Re: Optimizing simple calls in a dynamically typed language? cwarren89@gmail.com (Curtis W) (2008-08-26)
Re: Optimizing simple calls in a dynamically typed language? lerno@dragonascendant.com (=?ISO-8859-1?Q?Christoffer_Lern=F6?=) (2008-08-27)
[6 later articles]
| List of all articles for this month |

From: =?ISO-8859-1?Q?Christoffer_Lern=F6?= <lerno@dragonascendant.com>
Newsgroups: comp.compilers
Date: Sat, 23 Aug 2008 13:38:06 -0700 (PDT)
Organization: Compilers Central
Keywords: OOP, optimize, types
Posted-Date: 24 Aug 2008 14:40:48 EDT

I am playing around with some ideas for a compiled dynamically typed
language i.e. no VM.


What bugs me is that in a dynamically typed language without
primitives, code that looks like this in C:


int j;


... <code setting the value of j>


int i = j * 5 + 3;


Would usually compile to something like 2 dynamic calls, first on j
and then on the result of j * 5.


While one can discuss the extra overhead of dynamic dispatch, in this
example the C code doesn't even turn up a single function call, and
because of the dynamic dispatch there is no hope to inline the calls.


The only idea that struck me as remotely feasible would be to inline
these types manually.


So my code


i = j * 5 + 3;


would compile to something like (ignoring conversions due to int
overflow):


Id temp = IS_INT(j) ? j * 5 : call(j, "mult", 5);
Id i = IS_INT(temp) ? temp + 3 : call(temp, "add", 3);


Where IS_INT is some macro that would do some bit-check to verify that
the object can be interpreted as an int.


Aside from being hideously ugly, I am not really sure that it is a
workable solution.


This obviously touches on the whole "how do you get a dynamic language
to run as fast as C" discussion. So, does anyone have any ideas or
pointers?


Post a followup to this message

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