Re: virtual machine efficiency

ed_davis2 wrote:
> I have developed a simple stack based virtual machine. I would like
> it to be as efficient as possible, in terms of both speed and object
> code size. Size, as in size of the object code the VM processes
> (byte-code), and not necessarily the size of the VM.


> Is there a way I can have both fast loading of operands, and small
> byte-code size?


1) You could inserts nops before the op-code to ensure that the value
was always word-aligned. However this would be too slow since your
interpreter would need to handle the nops.


2) You could still align your data on a word-boundary. The interpreter
would notice the alignment of the op-code, and implicitly skip 0-3
bytes. The compiler would need to insert appropriate padding to ensure
the correct alignment.


case OP_LD:
if(IP&3) IP = (IP&~3) + 4;
operand = *(int*)IP;


3) You could have variable-width op-codes. Have 4 load instructions
with widths 1,2,3 and 4 that align the data following the op-code. But
I don't see much advantage over 2).


case OP_LD0:
operand = *(int*)IP;
IP += 4;
...
break;
case OP_LD1:
IP ++;
operand = *(int*)IP;
IP += 4;
...
break;
case OP_LD2:
IP += 2;
operand = *(int*)IP;
IP += 4;
...
break;
case OP_LD3:
IP += 3;
operand = *(int*)IP;
IP += 4;
...
break;


4) You could store values out-of-stream. But this is slightly less
efficient.


5) (copied from Anton Ertl's post) reorder op-codes and move
word-aligned data away from its op-code.


I think in the cases of 2) and 3), although there is occasional
padding, the interpreter has much less to do than in the more complex
schemes.


Calum

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