[Haskell-cafe] Re: Haskell Paralellism

[Simon Marlow]

Dominik Luecke wrote:

> I am trying to use the code 
> 
> rels list = 
>     let 
>         o1 = (map makeCompEntry) $ head $ splitList list
>         o2 = (map makeCompEntry) $ head $ tail $ splitList list
>         o3 = (map makeCompEntry) $ head $ tail $ tail $ splitList list
>     in
>       case (head $ tail $ tail $ tail $ splitList list) of

you've written 'splitList list' 4 times here.  The compiler might be clever 
enough to common them up, but personally I wouldn't rely on it.  Your code 
can be shortened quite a lot, e.g:

       let
           (o1:o2:o3:rest) = map makeCompEntry (splitList list)
       in
         case rest of
           ...

>         [] -> o1 `par` o2 `par` o3 `seq` o1 : o2 : o3 : []
>         _  -> 
>             let o4 = rels (head $ tail $ tail $ tail $ splitList list)
>             in
>               o1 `par` o2 `par` o3 `par` o4 `seq` 
>               o1 : o2 : o3 : o4

without knowing what splitList and the rest of the program does, it's hard 
to say why you don't get any parallelism here.  But note that when you say:

o1 `par` o2 `par` o3 `seq` o1 : o2 : o3 : []

what this does is create "sparks" for o1-o3 before returning the list 
[o1,o2,o3].  Now, something else is consuming this list - if whatever 
consumes it looks at the head of the list first, then you've immediately 
lost the opportunity to overlap o1 with anything else, because the program 
is demanding it eagerly.

All this is quite hard to think about, and there is a serious lack of tools 
at the moment to tell you what's going on.  We do hope to address that in 
the future.

Right now, I suggest keeping things really simple.  Use large-grain 
parallelism, in a very few places in your program.  Use strategies - parMap 
is a good one because it hides the laziness aspect, you don't need to worry 
about what is getting evaluated when.

Cheers,
	Simon