Re: Dynamic Typing Efficiency

Thanks everyone. I am going to try to implement a static analysis
algorithm along with static versions of all of my opcodes so that they
can be used when possible.


For now I am using an nxn matrix lookup table. Like so:


enum { INT, BOOL, REAL, STRING }
enum { II, IB, IR, IS, BI, BB, BR, BS, RI, RB, RR, ... }


char typelook[][] =


                    INT BOOL REAL STRING
INT II IB IR IS
BOOL BI BB BR BS
REAL RI RB RR RS
STRING SI SR SR SS


This way the comparison is simpler.


switch (typelook[type1][type2])
{
        case II:


        case IB:


        case IR:


        .
        .
        .
}




Jeff Kenton wrote:
> One other approach not yet mentioned is to do static analysis where
> possible, so that you can avoid runtime type checking when it's not
> necessary.
>
> clearm@comcast.net wrote:
> > Hello,
> >
> > I am writing a small, python-like scripting language that uses
dynamic
> > typing. I am also writing a stack-based virtual machine to go with
> > it.
> >
> > I have read many papers and posts about improving the efficiency of
> > VMs - for example by using threaded dispatch instead of switch
> > statements.
> >
> > The problem I have is that dynamic typing seems to be extremely
> > inefficient when you have a large number of types. For example, if
I
> > have integers, doubles, strings, booleans, and various compound
types,
> > then an ADD instruction would have to look like this:

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