Sequencing IO actions in parallel

Question

I have a function that returns an IO action, ``` f :: Int -> IO Int ``` I would like to compute this function in parallel for multiple values of the argument. My naive implementation was as follows: ``` import Control.Parallel.Strategies vals = [1..10] main = do results <- mapM f vals let results' = results `using` parList rseq mapM_ print results' ``` My reasoning for this was that the first `mapM` binds something of type `IO [Int]` to `results`, `results'` applies a parallel strategy to the contained list, and the `mapM_` finally requests the actual values by printing them - but what is to be printed is already sparked in parallel, so the program should parallelize. After being happy that it does indeed use all my CPUs, I noticed that the program is less effective (as in wall clock time) when being run with `+RTS -N8` than without any RTS flags. The only explanation I can think of is that the first `mapM` has to sequence - i.e. perform - all the IO actions already, but that would no…

Accepted Answer

Strategies are for parallel execution of pure computations. If it really is mandatory that your `f` returns an `IO` value, then consider using the `async` package instead. It provides useful combinators for running `IO` actions concurrently.

For your use case, `mapConcurrently` looks useful:

```
import Control.Concurrent.Async

vals = [1..10]
main = do
  results <- mapConcurrently f vals
  mapM_ print results
```

(I haven't tested though, because I don't know what your `f` is exactly.)

Sequencing IO actions in parallel

Solution

Problem