A successful lisp machine?

[Harvey J. Stein]

Martin Cracauer writes:
 > Harvey Stein wrote:
 > 
 > [...]
 > > I thing the best bet is to:
 > > 
 > >    1. Start with Linux (or one of the free BSDs for that matter) + a
 > >       lisp or scheme.
 > >    2. Write a loadable kernel module and/or the kernel patches needed
 > >       so that the lisp side doesn't have to fight the operating system.
 > 
 > Do you want to put the Lisp system in the kernel or a LKM?
 > 
 > Or just the "support" stuff such as memory tuning interfaces to
 > synchronice paging and GC and or replacement for the siggnal
 > messaging mechanism? 

Well, I don't know about *me* putting it in... ;-).  But I think it's
a fairly subtle problem to decide exactly what hooks need to go into
the kernel proper, what should go in as a kernel module, and what
should stay in user space.  Some of the issues, as I see them, are:

   -I suppose one needs to put enough in to make Lisp perform well and
    interact well with libC, libraries written in C in general, and
    the kernel system calls themselves.
   -If the changes aren't *too* big, one might be able to get them
    folded into the official kernel release.
   -If the changes *are* big, one might be able to get a minimal set
    of hooks into the official kernel release, and put most of the
    needed code into a loadable kernel module.  The dosemu people
    have been known to do something along these lines.
   -If everything that's needed can be done in a loadable kernel
    module, then one doesn't need to convince any kernel developers
    that one's changes should get folded into the source tree - just
    distribute the module separately.
   -Since kernel memory is nonpagable, one typically wants to do as
    much as possible in user space so that memory can be better
    managed.  I hear that system call overhead in Linux is fairly low,
    so this shouldn't imply much of a performance penalty.

In any case, I'd expect that 

   a) it'd be difficult to get a full Lisp system into the official
      kernel sources, and 
   b) it probably wouldn't be so desirable anyway.

So, the answer to your question is that I was mostly thinking of using
a loadable kernel module for the support stuff, and begging the kernel
developers to add whatever additional hooks are needed by said
module.

-- 
Harvey J. Stein
Berger Financial Research
abel@netvision.net.il