Why is there no implicit parallelism in Haskell?

Question

Haskell is functional and pure, so basically it has all the properties needed for a compiler to be able to tackle implicit parallelism.

Consider this trivial example:

f = do   a <- Just 1   b <- Just $ Just 2   -- ^ The above line does not utilize an `a` variable, so it can be safely   -- executed in parallel with the preceding line   c <- b   -- ^ The above line references a `b` variable, so it can only be executed   -- sequentially after it   return (a, c)   -- On the exit from a monad scope we wait for all computations to finish and    -- gather the results 

Schematically the execution plan can be described as:

               do                 |       +---------+---------+       |                   |   a <- Just 1      b <- Just $ Just 2       |                   |       |                 c <- b       |                   |       +---------+---------+                 |            return (a, c) 

Why is there no such functionality implemented in the compiler with a flag or a pragma yet? What are the practical reasons?

Answer 1

This is a long studied topic. While you can implicitly derive parallelism in Haskell code, the problem is that there is too much parallelism, at too fine a grain, for current hardware.

So you end up spending effort on book keeping, not running things faster.

Since we don't have infinite parallel hardware, it is all about picking the right granularity -- too coarse and there will be idle processors, too fine and the overheads will be unacceptable.

What we have is more coarse grained parallelism (sparks) suitable for generating thousands or millions of parallel tasks (so not at the instruction level), which map down onto the mere handful of cores we typically have available today.

Note that for some subsets (e.g. array processing) there are fully automatic parallelization libraries with tight cost models.

For background on this see Feedback Directed Implicit Parallelism, where they introduce an automated approach to the insertion of par in arbitrary Haskell programs.