Re: Code compiling (marshalling?)

[Marius Vollmer <mvo at zagadka dot ping dot de>]

Ian Bicking <ianb@colorstudy.com> writes:

> On Wed, Aug 09, 2000 at 11:40:58PM +0200, Marius Vollmer wrote:
> > Yep.  This was actually the point of my evaluator experiment:
> 
> How would you summarize the results of your experiment?

Well, the experiment hasn't officially ended, but so far I would say:
it worked out quite well, and it certainly was fun to undertake, but
it is far from being a serious candidate for replacing the current
evaluator.

My evaluator is `complete' in that it should implement all of Scheme
correctly, including continuations (but I have not tested them).  For
example, it can boot into the regualr repl and run my guile-gtk
programs.  It is not fast however.  Making it go fast enough might
require to make it significantly uglier.

The main point, writing the internal `machine code' to disk, works
well, too.  It is not as fast as I hoped it would be, and I need to
investigate where the time is spent.  Loading the code itself is just
one mmap, but recreating the Scheme literal objects like symbols,
strings, lists likely takes quite some time.

I think that my basic idea of using tree-codes like the internal
evaluator has not succeeded.  A byte-code interpreter is probably
easier to make fast and clean at the same time.  The rest of the
experiment is largely independent what kind of code (tree-codes or
byte-codes) is being saved to disk, so I think that part should not be
scratched.

There are two things that might be further examined starting from the
current code: how to efficiently write a subset of the Scheme objects
to disk and load them back (fasloading, machine code would be among
the writable objects); and what it means to have a ahead-of-time
compiler (module issues, macro issues, optimization issues).