Re: Automatic parallelization - was Re: LISP Object Oriented?



On 30 Jan 2007 10:51:11 +0100, Marcus Breiing
<usenet@xxxxxxxxxxxxxxxxxxxxxxxx> wrote:

George Neuner <gneuner2/@comcast.net> writes:

I can envision a distributed solution based on aggressive evaluation
of futures ... starting from any language with call-by-need
semantics.

Programs written for lazy languages will typically serve up lots of
computations that are _never_ used.

This is true. However, I would make the case that the programmer is
ill equipped to enumerate the computations that _will_ be used in any
particular run of the program, and therefore source level methods can
only be partially effective.

If you aggressively evaluate them anyway, doing it in parallel
without starving the original threads may avoid nontermination,

Backward chaining computations ensures that data supporting the
computation is available when needed, but it is a strictly serial
process. Forward chaining allows any partial computation to be
performed whenever its supporting data becomes available, possibly
ahead of its need.

Futures from program paths that aren't taken may never be evaluated
because of unsatisfied preconditions. Some useless computations will
slip through that though. The ideal would be some method of deciding
which futures are guaranteed to be used and only computing those
futures in parallel - leaving everything else to be computed lazily.


but could nevertheless be a horribly inefficient use of those
cores.

As opposed to running serial programs that leave them idle? There is
a lot of inherent parallelism in programs which is currently not
exploited. I agree, in principle, that maximal aggression is overkill
and a waste of resources ... but the current situation - serial
plodding with ad hoc programmer driven parallelization - is not
desirable either.

Do you have some other idea?

George
--
for email reply remove "/" from address
.