Hi All,
Would anyone with experience of Parallel Lisp care to comment on how
well these have performed, and how feasible it is to write parallel
Lisp code? I'm generally thinking of implementations from the 80s or
early 90s which ran on massively parallel hardware.
My reason for asking is due to the trend towards multi-core processors.
In a nutshell the hardware designers today seems to be up against hard
physical limits, they can't push the GHz much higher with current
designs as they cant get the electrons round the cpu fast enough, and
they can't make the chips much smaller due to cross-talk (or something
like that - I'm not a hardware person). So the answer seems to be a
move towards multiple core processors.
If Intel hadn't been running into these problems then we should be
using 10 Ghz Pentiums by now. The rate of clock rate advance has
definitely slowed down!
http://www.gotw.ca/publications/concurrency-ddj.htm (ignore any
references to C++, its a general problem)
So multi-core is the way forwards, but where does this trend take us?
Today dual-core and quad-core chips are commonplace, but consider the
new Sun Sparc T1.
http://www.sun.com/processors/UltraSPARC-T1/
This chip contains 8 cores with each capable of running 4 concurrent
threads. So from a programmers point of view this might look like a 32
core chip! The next generation Sparc (due 2008) will actually contain
32 real cores ~ possibly giving 128 threads. The trend is clearly
towards a massively parallel future.
This is a big hurdle facing the C++/Java/C# communities. Typical OO
designs often scale poorly, multi-threaded access is controlled via
judicious use of mutex's. The end result is something difficult to
maintain and full of bottlenecks around central data structures. I've
seen too many client/server systems scale poorly beyond 10-20 threads.
Now imagine running on a 128 core machine!
If C++ remains a poor language for multi-threaded programming then it
will cease to remain relevant as a performance oriented language (those
are the sentiments of Herb Sutter).
So I'm looking forward to hearing from Lispers. (As a side note it
would seem that Haskell programmers view referential transparency as
an important building block for concurrent programmers).
Best wishes,
Mike Thompson