Hi.
On page 222 in "ANSI Common Lisp" Paul Graham writes:
"In Lisp implementations with bad garbage collectors, programs that
cons a lot tehnd to run slowly. Until recently, most Lisp
implementations have had bad garbae collectors, and som it has become
a tradition that efficient programs should cons as little as possible.
Recent developments have turned this conventional wisdom on its head.
Some implementations now have such sophisticated garbage colletors
that it is faster to cons up new objects and throw them away tnan it
is to recycle them."
My question is: Can someone give me the name of a few Common Lisp
implementations with good garbage collectors, using the above
definition?
--
(Rmz)
Bj\o rn Remseth !Institutt for Informatikk !Net: ···@ifi.uio.no
Phone:+47 22855802!Universitetet i Oslo, Norway !ICBM: N595625E104337
In article <··············@tyrfing.ifi.uio.no>,
Bj�rn Remseth <···@tyrfing.ifi.uio.no> wrote:
>My question is: Can someone give me the name of a few Common Lisp
>implementations with good garbage collectors, using the above
>definition?
The buzzword to look for in descriptions of particular CL implementations
is "generational GC" or "ephemeral GC". This technique was pioneered by
Symbolics, and most major commercial Lisps now offer it.
--
Barry Margolin, ······@bbnplanet.com
GTE Internetworking, Powered by BBN, Cambridge, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
* Bj�rn Remseth wrote:
> My question is: Can someone give me the name of a few Common Lisp
> implementations with good garbage collectors, using the above
> definition?
I think that almost any modern Lisp will meet this definition for a
suitably chosen program and a reasonable amount of physical memory.
You need a copying GC, and one that can be persuaded to look at only
`interesting' data when it runs. This usually translates into a
generational GC, but it doesn't necessarily have to.
For instance I have a program which conses bignums furiously, although
only a small number are live at any one time. I ran this on CMUCL,
having told the GC immediately before I ran the program that
everything then existing was static, and telling it to GC suitably
infrequently. It spends an absolutely negligible time in GC (1% or
something, perhaps less, because it only has about 5 live objects to
copy), so the performance must be dominated by the allocation
performance, and this should be very good (check for enough free space
(a subtraction) add n to a pointer, initialize the object).
I guess the real advantage of a generational collector is that they
can intuit what is interesting in cases which aren't as trivial as
this.
--tim
Bj�rn Remseth wrote:
>
> My question is: Can someone give me the name of a few Common Lisp
> implementations with good garbage collectors, using the above
> definition?
I use Allegro Common Lisp (4.3 for Unix) daily, and think very highly of its
GC. I can't compare it with the others, though, as I haven't tried them.
-- Scott
* * * * *
To use the email address, remove all occurrences of the letter "q".