Hi,
I am about to buy a new machine with an Intel Core 2 Quad Processor
(http://www.intel.com/products/processor_number/chart/core2quad.htm).
I will run the 64bits flavor of Ubuntu. I would like to know what are
the consequences regarding the Common Lisp implementations I may use
(I am now using CMUCL). I would like to stay with a free version
(CMUCL, SBCL, ECL, CLISP etc...)
I will use the machine for desktop, programming and number crunching
applications.
It is the first time I will use a 64bits architecture, I am not sure
what amount of RAM I should buy. Will the same (common lisp) programs
occupy significantly more memory (twice ?) ?
What is your experience running CL on 64bits processors ?
Did you get an increase of performance (at comparable frequencies) ?
Is the increase of address space the main benefit ?
Any hints will be apreciated.
Thibault Langlois
In article <························@p47g2000hsd.googlegroups.com>,
Thibault Langlois <·················@gmail.com> wrote:
> Hi,
> I am about to buy a new machine with an Intel Core 2 Quad Processor
> (http://www.intel.com/products/processor_number/chart/core2quad.htm).
> I will run the 64bits flavor of Ubuntu. I would like to know what are
> the consequences regarding the Common Lisp implementations I may use
> (I am now using CMUCL). I would like to stay with a free version
> (CMUCL, SBCL, ECL, CLISP etc...)
>
> I will use the machine for desktop, programming and number crunching
> applications.
>
> It is the first time I will use a 64bits architecture, I am not sure
> what amount of RAM I should buy. Will the same (common lisp) programs
> occupy significantly more memory (twice ?) ?
2GB or more? 4GB is fine.
>
> What is your experience running CL on 64bits processors ?
Fine. LispWorks seems to run much faster in 64bit.
OpenMCL also runs in 64bit.
> Did you get an increase of performance (at comparable frequencies) ?
> Is the increase of address space the main benefit ?
Other benefits are:
* less consing for a lot of applications
* the x86 architecture has advantages in 64bit mode.
Especially it has more registers. The 32bit mode
is a bit 'crippled' when it comes to registers.
* the x86 machine may have some advantages in 64bit when
it comes to multimedia data processing due
to better/more/wider machinery
>
> Any hints will be apreciated.
>
> Thibault Langlois
--
http://lispm.dyndns.org
Rainer Joswig <······@lisp.de> writes:
> Other benefits are:
>
> * less consing for a lot of applications
It's worth nothing that this is related to faster integer performance,
since SBCL on x86-64 gives:
* (describe 'most-positive-fixnum)
MOST-POSITIVE-FIXNUM is an external symbol in #<PACKAGE "COMMON-LISP">.
It is a constant; its value is 1152921504606846975.
Constant documentation:
the fixnum closest in value to positive infinity
Less consing for bignums comes with it.
> * the x86 architecture has advantages in 64bit mode.
> Especially it has more registers. The 32bit mode
> is a bit 'crippled' when it comes to registers.
The actual numbers are 8 general-purpose registers on x86 and 16 on
x86-64.
Thibault Langlois <·················@gmail.com> wrote:
+---------------
| I am about to buy a new machine with an Intel Core 2 Quad Processor
| (http://www.intel.com/products/processor_number/chart/core2quad.htm).
| I will run the 64bits flavor of Ubuntu. I would like to know what are
| the consequences regarding the Common Lisp implementations I may use
| (I am now using CMUCL). I would like to stay with a free version
| (CMUCL, SBCL, ECL, CLISP etc...)
+---------------
You may not be interested in this combination, but just so you know,
the 32-bit version of CMUCL runs just fine under 64-bit versions of
Linux (e.g., 2.4.21-20.EL, 2.6.7, etc.).
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
On May 24, 3:09 am, ····@rpw3.org (Rob Warnock) wrote:
> Thibault Langlois <·················@gmail.com> wrote:
> +---------------
> | I am about to buy a new machine with an Intel Core 2 Quad Processor
> | (http://www.intel.com/products/processor_number/chart/core2quad.htm).
> | I will run the 64bits flavor of Ubuntu. I would like to know what are
> | the consequences regarding the Common Lisp implementations I may use
> | (I am now using CMUCL). I would like to stay with a free version
> | (CMUCL, SBCL, ECL, CLISP etc...)
> +---------------
>
> You may not be interested in this combination, but just so you know,
> the 32-bit version of CMUCL runs just fine under 64-bit versions of
> Linux (e.g., 2.4.21-20.EL, 2.6.7, etc.).
>
I am interested, does this mean that I can dump a core and use it on
32bit machines ?
> -Rob
>
> -----
> Rob Warnock <····@rpw3.org>
> 627 26th Avenue <URL:http://rpw3.org/>
> San Mateo, CA 94403 (650)572-2607
Thibault Langlois <·················@gmail.com> wrote:
+---------------
| ····@rpw3.org (Rob Warnock) wrote:
| > You may not be interested in this combination, but just so you know,
| > the 32-bit version of CMUCL runs just fine under 64-bit versions of
| > Linux (e.g., 2.4.21-20.EL, 2.6.7, etc.).
|
| I am interested, does this mean that I can dump a core and use it on
| 32bit machines ?
+---------------
Yes, since you're only running in a purely 32-bit world anyway.
But note Eric Marsden's parallel comment about needing to
have the 32-bit environment installed in your 64-bit Linux.
"Most [64-bit] distributions do so [by default], but not all..."
-Rob
-----
Rob Warnock <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
From: Eric Marsden
Subject: Re: Common Lisp on 64bits, looking for advice
Date:
Message-ID: <87myzu2mji.fsf@free.fr>
>>>>> "rw" == Rob Warnock <····@rpw3.org> writes:
rw> You may not be interested in this combination, but just so you know,
rw> the 32-bit version of CMUCL runs just fine under 64-bit versions of
rw> Linux (e.g., 2.4.21-20.EL, 2.6.7, etc.).
true, but only if you have installed a 32-bit environment in that
AMD64 GNU/Linux installation. Most distributions do so, but not all:
on Debian you must install the libc6-i386 package, for example.
CMUCL also won't be able to load any 64-bit libraries.
It's also possible to install a 32-bit "world" in a chroot and run
CMUCL there.
--
Eric Marsden
(message (Hello 'Thibault)
(you :wrote :on '(23 May 2007 09:59:26 -0700))
(
TL> I am about to buy a new machine with an Intel Core 2 Quad Processor
TL> (http://www.intel.com/products/processor_number/chart/core2quad.htm).
if i'd buy for myself, i'd better buy new dual core E6850. when it will be
released, it will cost same as quad-core, but it works at 3 GHz speed
instread of 2.4 of Q6600, and with 1.3 GHz FSB.
certainly number crunching code can work faster on quad-core processor, but
there are many places when it's hard to make parallel code, and in such
places E6850 will be faster.. and there is GC, which as far as i know runs
only on one core on current implementations..
TL> I will run the 64bits flavor of Ubuntu. I would like to know what are
TL> the consequences regarding the Common Lisp implementations I may use
TL> (I am now using CMUCL). I would like to stay with a free version
TL> (CMUCL, SBCL, ECL, CLISP etc...)
afaik only SBCL and OpenMCL are able to run code on multiple cores
simultaneously. i've heard something about multithreading in ECL, but i
suspect it's not mature enough. and ABCL can do this, but most likely you
won't like implemenation on top of Java VM.
)
(With-best-regards '(Alex Mizrahi) :aka 'killer_storm)
"I am everything you want and I am everything you need")
Thibault Langlois wrote:
> What is your experience running CL on 64bits processors ?
SBCL works beautifully.
> Did you get an increase of performance (at comparable frequencies) ?
Yes:
http://www.ffconsultancy.com/languages/ray_tracer/results.html
> Is the increase of address space the main benefit ?
Better floating point performance is much more important for me.
--
Dr Jon D Harrop, Flying Frog Consultancy
The F#.NET Journal
http://www.ffconsultancy.com/products/fsharp_journal/?usenet
On May 24, 10:16 am, Jon Harrop <····@ffconsultancy.com> wrote:
>
> Better floating point performance is much more important for me.
Have you tried OCaml, Haskell, or F#? Or even gcc?
I'm sure these will give you the floating point performance you
desire.