

Re: sun and symbolics development environments

In article <49@spar.SPAR.SLB.COM> you write:
>From: "Chunka Mui" <C.AITCMUI@chip.uchicago>
>There's been a lot of discussion recently comparing and contrasting
>the Sun and Lispm development environments but this discussion has
>focused primarily on the software side of the issue.  How do they
>compare from a strictly hardware (and maybe very low level system
>software) standpoint?  Is there anything that one can do that the
>other can't because of implicit restrictions?  Is this a naive
No, just a very difficult one.  Remember, like all benchmarks, your
mileage may vary.

First, ignoring the environment, GC and floating point issues, the 
performance of a Sun 3/160 running either Lucid or Franz Lisp is anywhere 
from .5 to 2 times the speed of a Symbolics machine.  I am willing to
claim that a 68020 running at 16MHz is roughly comparable in speed to
a Symbolics machine.  Moving to a Sun 3/260 gives a factor of two 
performance increase with no change in your code.  The Sun 4's are supposed
to be another factor of 2 faster still but I haven't had a chance to
benchmark their lisp performance.

OK, now the caveats.

First the environment.  This is religeous and I'm not in the mood to
start the argument again..... :-)

Second, GC.  All Lisps must GC.  Symbolics machines have a very nice
GC that is almost invisible to the user.  On the other hand both Franz
and Lucid Lisp must stop all work so that the entire Lisp image can 
be checked for garbage.  For my work the amount of time spent GC'ing
hasn't been excessive, certainly less than a factor of two in performance.
Again, the number of times GC is necessary will be dependent on how much
time your application spends generating garbage to doing real work.
Finally, if you must use a stop and copy GC (like the current releases
from Franz and Lucid) then you MUST have enough physical memory so
your entire image can fit into core.  If you don't then you will page
to death and performance will be horrible.

Third, floating point.  Originally both Franz and Lucid did software
(boxed) floating point.  Lucid loaned us a pre-pre-pre-release of a 
compiler that did floating point correctly and its performance (on a 160)
was within 10-15% of a C algorithm and the same code on a Symbolics machine
(I forget whether the Symbolics machine had an IFU or an FPA, each which
makes about a 40% difference on this benchmark).  I'm not sure if Lucid
is shipping this new compiler to customers yet but if not then it will
be any day.  Franz is working hard on this problem.

P.S.  In the past year or two Sun has increased the performance of their
Lisp engines by about a factor or 4 and TI is talking about a factor of 5;
I'm looking forward to see what Symbolics delivers with their Ivory chip.