🚀 go-pugleaf

I would be interested in receiving some information about the state of
the art of Haskell compilers: from  what I read  in this newsgroup and
in   the Haskell   mailing list   I     can   induce that   sequential
implementations are almost  fully developed, but  what  about parallel
ones ?  Does anyone have any idea  on how the parallel implementations
are going on ? Moreover, among the parallel implementations, is anyone
developing a transputer  one ?  and, if  so, can anyone   give me some
details of it ?

Any help will be appreciated, and I promise  to post a summary of what
I will receive in this newsgroup.

Giancarlo



Internet charmi@cs.Buffalo.Edu UUCP charmi%cs.buffalo.edu@ubvms.bitnet Bitnet
          !{ames,boulder,decvax,rutgers}!sunybcs!charmi

	            Grapes, not strawberries!

This summer I hope to modify the Yale Haskell compiler to emit Mul-T
code for the Encore Multimax instead of T code.  Para-functional
annotations added by the programmer to the Haskell source code will
indicate the desired operational behavior (parallelism and order of
evaluation).  Since the Multimax is a shared memory computer, it
avoids some of the complexities that a transputer implementation would
have to deal with.

Duke

Someone asked about whether anyone was working on 
parallel implementations of Haskell.

Good news: we are; we have a parallel implementation running on the
GRIP multiprocessor, with absolute wall-clock speedup over the same
programs running on a comparable uniprocessor (never to be taken 
for granted!).  This has only recently sprung to life, so it will be
a while before we can report proper results.

Bad news: it only runs on GRIP at present, so that rather limits its
distribution.  We have access to a Meiko transputer machine, but it
is quite a lot harder to deal with a distributed memory architecture.  The
compiler would port rather easily to a shared-memory multiprocessor,
but we don't have access to one at present.

Simon Peyton Jones
Glasgow University

In article <25363@cs.yale.edu> peterson-john@CS.Yale.EDU (John C. Peterson) writes:
>Two Haskell implementations are currently in the works.  Groups at Yale
>and Glasgow are working hard to make Haskell available to the rest of the
>world.
>
> ... the Glasgow group is using LML.  In the long run, we plan to supply 
> an entire environment including incremental compilation, 
> a good debugging system, and other Haskell specific software tools.  

This is to confirm John's announcement for the Glasgow compiler
(available RSN).  It is not necessary to have LML to be able to use
Haskell, though the compiler will handle both Haskell and LML.  The
speed of Haskell executables is comparable to LML (~50K-70K fcs on a
Sun 3/50 for what that's worth).

We will also be working on a debugger and some other goodies.  Details
to follow.

>Yale's implementation will be far superior to Glasgow's! :-)

Not so: I have some fiendish examples to try on the Yale compiler :-) :-)

Kevin



-- 
This Signature Intentionally Left Blank.	E-mail: kh@cs.glasgow.ac.uk