Re: [DotGNU]Who is working on the IL VM?

[Rhys Weatherley]

Martin Coxall wrote:

> How much progress has portable.net made on this front? I am concerned about
> effort duplication between Mono's VM (which for historical reasons, I should
> stress is my pet project <g>) and portable.net.

I am also concerned about duplication.  In particular,
Mono's duplication of Portable.NET.  For the 10,000th
time: I was here first.

In any case, it doesn't matter that there is duplication.
DotGNU needs a VM that works well with everything
else we are doing, so we will be building one.

Mono has more instructions implemented, but less of
the code "behind" each instruction.  I have more of the
code behind the instructions, but haven't yet hooked
them up.  It's a different project, with a different
approach.  Big deal.

Progress on the Portable.NET VM may appear to be
slow, but it is actually much further along than it looks.

I realised very early that 90% of what is needed for
an interpreter is also 60% of what is needed for the
compiler, assembler, and disassembler.  By building
the toolchain first, I am getting a lot of the VM for free.
And as an added bonus, I get the tools too.

Portable.NET's program loader is about 95% compliant
with the full ECMA Partition II spec, and is general
purpose enough to be used by a range of tools.  The
program writing code is also about 95% complete.
Mono is nowhere near that yet, and a lot of it is
hard-wired into the VM where other tools can't use it.

Portable.NET tries to hide a lot of the metadata
encoding knowledge from the tools that use it.  A benefit
of this is that I now think it is possible to transparently
support Java class files in the program loader in such
a way that most tools won't even realise they are
dealing with Java.

With two interpreter loops in the VM, it may even be
possible to run IL and JVM bytecode side by side in
the same engine, and to have one type of class call
another transparently.  There are other people on the
DotGNU list investigating other approaches besides
IL and JVM: their engines could be turned into
co-interpreters also.  Thus, new approaches get full
access to the existing C# and Java class libraries for free.

Because Mono drags the internals of metadata tables
up to the tools and the VM, this won't be possible without
a complete rewrite of their API's and architecture.

I think you'll be quite surprised how quickly the
Portable.NET VM will come together in the next
few months.  There are lot of dots already in place:
I just need to join them.

Cheers,

Rhys.