From: Michael Travers
Subject: Re: possibly a trivia question...
Date:
Message-ID: <162@mit-amt.MEDIA.MIT.ErU>
Refere.rpi <·····@bu-cs.BU.EDU>
Reply-Po: ··@media-lab.media.mit.edu (Michael Travers)
Organieation: MIT Media Lab, Cambridge MA
Lines: 27
21 icle <·····@bu-cs.BU.Er
Xi ···@bu-cs.BU.EDU (Barry Shein) writes:
>
> n Common Lisp, give Sunw
>
> (setf (get 'foo 'bar) 'goo)
>
>lleret should:
>
> (prog (foo) (get 'foo 'bar))
>
>return (prog could be >answer should be basically the same)?
I would have thought so too, but it turns out the prog is not like
progn in tdefined in terms of tagbody (see ClTL p. 133) and tagbody returns nil
by default (p. 130).
Binding a variable never affects its property list, so that's
irrelevant.
>One implementation I tried returned 'goo and the other NIL.
The first one is apparently in error.
--
Michael Travers / MIT Media Lab / ··@media-lab.media.mit
What Common Lisps run on the DEC 3100? I assume Vaxlisp has been ported,
but what about Allegro and Kyoto? Which of these has the best foreign
function interface?
Also, I'm interested in running CLOS. What experience have people had
with the efficiency of this system? The book says it can be done very
efficiently, but I've heard people say it's a dog, in both speed and
memory usage. Who has the best implementation of CLOS?
Thanks in advance,
Wayne
In article <·····@pasteur.Berkeley.EDU> ·······@dogwood.Berkeley.EDU (Wayne A. Christopher) writes:
Also, I'm interested in running CLOS. What experience have people had
with the efficiency of this system? The book says it can be done very
efficiently, but I've heard people say it's a dog, in both speed and
memory usage.
Well, of course, there is no one CLOS implementation - just a CLOS spec. The
most widespread implementation is PCL, which is publicly available, but isn't
quite conformant to Chapters 1 & 2 of the CLOS spec (yet). We at Harlequin have
implemented our own CLOS which does conform to Chapters 1 & 2.
The trick to getting a fast CLOS implementation is to exploit the strengths of
your compiler, so that the critical things like method dispatch and slot access
have good performance. I expect that as CLOS takes hold in the Lisp world, we
will see more CLOS implementations closely tied into particular Lisp compilers
for this reason.
Gathering objective (no pun intended!) data on CLOS performance is difficult,
since there aren't any widely used benchmarks, but we have used CLOS
extensively with CLUE, as the implementation language for our window toolkit
built on CLUE, and throughout the LispWorks programming environment generally.
We're happy with the resulting performance.
Who has the best implementation of CLOS?
If I gave you my opinion on that, it'd be advertising (:-).
Thanks in advance,
Wayne
--
Regards,
Andrew.
+-----------------------------------------------------------------------------+
| Andrew Watson, ······@uk.co.harlqn -or- |
| Harlequin Limited, mcvax!ukc!harlqn!andrew |
| Barrington Hall, Barrington, Tel: +44 223 872522 |
| Cambridge CB2 5RG, UK Fax: +44 223 872519 |
+-----------------------------------------------------------------------------+
From: Mike Thome
Subject: Re: CLOS availability (was Re: Common Lisp on the DEC 3100)
Date:
Message-ID: <43681@bbn.COM>
In article <····················@jung.harlqn.uucp> ······@jung.harlqn.uucp (Andrew Watson) writes:
>In article <·····@pasteur.Berkeley.EDU> ·······@dogwood.Berkeley.EDU (Wayne A. Christopher) writes:
> Also, I'm interested in running CLOS. What experience have people had
> with the efficiency of this system? The book says it can be done very
> efficiently, but I've heard people say it's a dog, in both speed and
> memory usage.
CLOS implementations can be VERY efficient (as first demonstrated by TI's
implementation)... PCL (the first, the publicly available, the portable) is
not and cannot (in general) be as efficient as a native implementation because
of it's portability... and comparing a system like C++ to CLOS is classicly
apples-and-oranges.
*Many* lisp vendors are working on native CLOS implementations - I've actually
played with the TI pre-release product (for the TI explorer lisp machines) and
remain very impressed (no doggy that!). Symbolics has announced a version of
their own, but it's still a ways off... and I'm sure all the major CommonLisp
vendors are doing the same (on pain of not being able to provide full
CommonLisp to their customers).
>Gathering objective (no pun intended!) data on CLOS performance is difficult,
>since there aren't any widely used benchmarks, ...
Yes - in general, "real" systems seem to be best at measuring *overall*
performance - however, there are a number of useful standard measures - among
them: generic function dispatch speed measured relative to funcall speed for
various combinations of methods (i.e. single method gfn, single argument
dispatch, multiple-argument dispatch, dispatch speed on CL types relative to
CLOS classes), slot access relative to maybe aref or structure ref speed
(instance and class slots, all the various ways of getting at 'em), etc.
Perhaps the most interesting measurements are the breakevenpoints where using
CLOS begins to beatout old CommonLisp (i.e. using CLOS method dispatch instead
of typecase usually starts winning at around 10 methods/clauses in PCL on
symbolics).
> Who has the best implementation of CLOS?
>If I gave you my opinion on that, it'd be advertising (:-).
Not at all to detract from Harlequin's product (or anyone else's), but this
question will not be meaningfully unanswerable until Chapter 3 (the Metalevel)
of the CLOS spec is settled on and vendors implement it (that's where the hard
stuff is...)
-mike (······@bbn.com, ······@thalamus.bu.edu, ······@wombat.mit.edu)
From: John Carroll
Subject: Re: CLOS availability (was Re: Common Lisp on the DEC 3100)
Date:
Message-ID: <855@scaup.cl.cam.ac.uk>
In article <·····@bbn.COM> ······@vax.bbn.com (Mike Thome) writes:
>CLOS implementations can be VERY efficient (as first demonstrated by TI's
>implementation)...
Yes, they can be efficient -- however the first complete (Chapters 1 and 2)
commercially available implementation was produced by Procyon Research,
Cambridge UK, for the Apple Macintosh. It was released in May. I have been
using it since then and it is very quick.
In article <····················@jung.harlqn.uucp> ······@jung.harlqn.uucp (Andrew Watson) writes:
>Gathering objective (no pun intended!) data on CLOS performance is difficult,
>since there aren't any widely used benchmarks, ...
Procyon have some CLOS benchmarks (get hold of their CLOS publicity
handout -- their phone no. is +44 223 65011) e.g. TAK as a single-method
generic function, CALL-NEXT-METHOD with :BEFORE, :AFTER and :AROUND
methods etc. Does anyone else have a good set of benchmarks?
John Carroll (···@cl.cam.ac.uk)