From: ·····@markwatson.com
Subject: Q: experiences with ultra large memory LISP applications?
Date:
Message-ID: <889e1n$qjp$1@nnrp1.deja.com>
Hello all,
I would appreciate hearing experiences with ultra large
memory LISP applications on relatively inexpensive
hardware (e.g., one of the many commodity Intel based servers
with 4 gig of RAM). I understand that there are patches
to Linux that allow 4 gigs per process; has anyone tried
working with Franz, CMU, etc. using 4 gig heaps? Larger
heaps?
Thanks,
Mark Watson, author, programmer. www.markwatson.com
Sent via Deja.com http://www.deja.com/
Before you buy.
From: Joachim Achtzehnter
Subject: Re: Q: experiences with ultra large memory LISP applications?
Date:
Message-ID: <x5emafuvj6.fsf@soft.mercury.bc.ca>
·····@markwatson.com writes:
>
> I would appreciate hearing experiences with ultra large memory LISP
> applications on relatively inexpensive hardware (e.g., one of the
> many commodity Intel based servers with 4 gig of RAM). has anyone
> tried working with Franz, CMU, etc. using 4 gig heaps? Larger heaps?
With Franz Allegro things get tricky once heap sizes grow to a size of
the order of 1 Gb, especially when you are using foreign functions. You
have to fiddle with loading things in a certain order ad other tricks.
See
http://www.franz.com/support/docs/5.0/doc/faq/faq-entries/faq3-9.htm
Don't expect to be able to actually use the full 4 Gb address space.
Joachim
--
·······@kraut.bc.ca (http://www.kraut.bc.ca)
·······@mercury.bc.ca (http://www.mercury.bc.ca)
From: Robert Monfera
Subject: Re: Q: experiences with ultra large memory LISP applications?
Date:
Message-ID: <38A8D19D.C3B5CA15@fisec.com>
Joachim Achtzehnter wrote:
> With Franz Allegro things get tricky once heap sizes grow to a size
> of the order of 1 Gb, especially when you are using foreign
> functions.
[ACL FAQ reference elided]
Am I right when I think that it does not imply that other
implementations like LW or CMUCL do not have very similar constraints,
but rather that those limitations are not explained?
Also, reading the ACL explanation, it seems that much, if not all of the
limitation comes from the operating system. What do multi-processor
systems do with 4GB, if those limitations are indeed those of the OS?
Has anyone used CL on a 64-bit address space? Someone mentioned a
version of CMUCL on Alpha. Maybe Lisp vendors aregoing after Itanium if
it turns out to be successful.
Robert
* Philip Nikolayev <·······@is02.fas.harvard.edu>
| Is there a way to sort (with sort) a list of pairs of numbers by the
| value of the first element of each pair?
yes. (sort <sequence> <predicate> :key #'first) will use first to
extract the value from each element of the sequence before comparing.
#:Erik
* Philip Nikolayev <·······@is02.fas.harvard.edu>
| If I wanted to replace all the whole reals, such as 3.0, in a list with
| their integer equivalents, while leaving all the other reals intact, is
| there an easy way to do this?
consider a function f that accepts a number and returns the corresponding
integer if the number satisfies a predicate whole-real-p, or the number
unchanged if not. apply this function to every element of the list with
a suitable mapping function. you don't want this operation to destroy
the original list of values.
#:Erik
Hello!
If I use throw and catch in a recursive function, which the throw go
to the catch in the first call to the function? Or not, and then
where?
Thanks very much!
Philip
In article <··················@is01.fas.harvard.edu>,
Philip Nikolayev <·······@is01.fas.harvard.edu> wrote:
>If I use throw and catch in a recursive function, which the throw go
>to the catch in the first call to the function? Or not, and then
>where?
From both CLTL2 and the Hyperspec: "The most recent outstanding catch ....".
--
Barry Margolin, ······@bbnplanet.com
GTE Internetworking, Powered by BBN, Burlington, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
+ Philip Nikolayev <·······@is02.fas.harvard.edu>:
| Is there a way to sort (with sort) a list of pairs of numbers by the
| value of the first element of each pair? The list looks something like
| this: ((3 4) (7 3) (9 11) etc.)
While the real experts discuss more lofty issues, I'll try offering
the following advice:
(sort some-list-of-pairs #'< :key #'first)
| I am quite new at lisp. Thanks a lot!
You should go get the HyperSpec and learn to answer such questions for
yourself. You'll probably find it at <http://www.harlequin.com/>.
Good luck!
--
* Harald Hanche-Olsen <URL:http://www.math.ntnu.no/~hanche/>
- "There arises from a bad and unapt formation of words
a wonderful obstruction to the mind." - Francis Bacon
Philip Nikolayev <·······@is02.fas.harvard.edu> writes:
> Hello!
>
> Is there a way to sort (with sort) a list of pairs of numbers by the
> value of the first element of each pair? The list looks something like
> this: ((3 4) (7 3) (9 11) etc.)
>
> If not with sort, what's the best way to do this?
>
> I am quite new at lisp. Thanks a lot!
Use the :KEY argument to SORT.
(sort '((3 4) (7 3) (9 11)) #'< :key #'first)
=> ((3 4) (7 3) (9 11))
Christopher
* Philip Nikolayev
> Is there a way to sort (with sort) a list of pairs of numbers by the
> value of the first element of each pair? The list looks something like
> this: ((3 4) (7 3) (9 11) etc.)
See the hyper spec:
http://www.harlequin.com/support/books/HyperSpec/FrontMatter/index.html
that is the SORT function:
http://www.harlequin.com/support/books/HyperSpec/Body/fun_sortcm_stable-sort.html
You can use the keyword argument :KEY, like:
(setq l (list '(3 4) '(7 3) '(9 11)))
==> ((3 4) (7 3) (9 11))
(sort l #'> :key #'car)
==> ((9 11) (7 3) (3 4))
--
Jon Haugsand
Norwegian Computing Center, <http://www.nr.no/engelsk/>
<···················@nr.no> Pho: +47 22852608 / +47 22852500,
Fax: +47 22697660, Pb 114 Blindern, N-0314 OSLO, Norway
Hello!
Suppose I have a list of number pairs like
((1 2) (1 7) (1 -3) (4 0) (4 2) etc... )
which is SORTED in ascending order by the first element of each
pair. Now, what I would like to do is replace each subset set of pairs
with the same first element and replace then with just one pair with
the same first element, whose second element is the sum of all the
second elements of those pairs that have the same first element, so I
get:
((1 6) (4 2) etc... )
What is an elegant way to do this? Any tips would be greatly
appreciated!
Thanks so much in advance!
Philip "Still new to LISP" Nikolayev
Philip Nikolayev <·······@is04.fas.harvard.edu> writes:
> Hi! I'm trying to do something to each member of a list of simple
> lists, and I tried to do this by using mapcar twice, as in
>
> (mapcar #'mapcar #'function '(lst))
>
> but that doesn't work. What's the proper way to do this?
(mapcar #'(lambda (list)
(mapcar #'my-fun list))
list)
Dunno if this is proper though (let alone correct :-)
//Raymond.
--
Raymond Wiker, Orion Systems AS
+47 370 61150