[not about] gc-by-area and host uptimes

[cal@THINK.COM]

   Date: Wed, 15 Feb 89 23:31 EST
   From: Reti@stony-brook.scrc.symbolics.com (Kalman Reti)

       Date: Wed, 15 Feb 89 20:55:01 CST
       From: forbus@p.cs.uiuc.edu (Kenneth Forbus)

   (b) Reusing code over multiple
       hardware systems has nothing to do with the underlying hardware.
       Anybody remember the Interlisp virtual machine?  Once you had it
       running you could port over everything else pretty easily, since all
       the tools were written in lisp.  [Whether or not you would want those
       tools is yet another question :-)]
   Ah, but if you had one implementation of that virtual machine where
   spaghetti stacks were horrendously slow, and another where they were
   reasonable, the applications would be unusable on one and (perhaps)
   usable on the other.  This is precisely the point I am making.

You are confusing relative speeds and acceptable speeds.  As far as I'm
concerned, there is little that a Sun4 can't do several times faster than a
36xx.  If the operations appear to a human to run in reasonable amounts of
time on a 36xx, then surely a human will be even happier with the
performance on a Sun4.  That's true regardless of the relative speed of
instructions on the Sun4.  So I believe that you are in error when you
imply that things like Genera could not run on a Sun4.  I suspect that with
a little bit of tuning, it would run several times faster than on a 36xx.

   If we were a giant company with a captive fab line and process design
   engineers to tweak the processes specifically for our chip, I assure
   you we would.  As a much smaller company, we can only make use of the
   commercially available technology, which is bound to be several
   years behind the best the semiconductor giants can muster.

This is precisely why Symbolics should be concentrating on software, and
not hardware.  You are bound to lose if you are always behind the
semiconductor giants.  Why try to beat them at a game you can't win?

								       But if
       When I benchmark my code on generic hardware, I DO NOT turn off type
       checking, I DO NOT install extra declarations, etc.  I have enough on
       my hands w/o trying to make up for deficiencies in the lisp
       environment.  And the generic stuff is really cleaning up in terms of
       performance on my code.
   It would be helpful to hear some details about this, what type of code,
   doing what sort of operations, what sort of generic machine.  There are
   many optimizations we can make to our system, and we want to be responsive
   to the needs of our customers.

I can give you many examples of large systems that now operate
significantly faster on a Sun4 than on a Lispm.  For example, with Lucid's
new EGC, performance on GC heavy code has gone up very significantly.  I
can compile *and* load several hundred thousand lines of code on a Sun4 in
the *same* amount of time it takes to just load it on my 3645.  This is for
a Lisp and EGC with no special hardware.  How do you explain that?