Is there some substitute of map
which evaluates the list in parallel? I don't need it to be lazy.
Something like: pmap :: (a -> b) -> [a] -> [b]
letting me pmap expensive_function big_list
and have all my cores at 100%.
Is there some substitute of map
which evaluates the list in parallel? I don't need it to be lazy.
Something like: pmap :: (a -> b) -> [a] -> [b]
letting me pmap expensive_function big_list
and have all my cores at 100%.
Besides using explicit strategies yourself as Tom has described, the parallel package also exports
parMap
:where the strategy argument is something like
rdeepseq
.And there's also
parMap
in the par-monad package (you step out of pure Haskell, and into a parallel monad):The par-monad package is documented here.
Yes, see the parallel package:
will evaluate each element of the list in parallel via the
rdeepseq
strategy. Note the use ofparListChunk
with a good chunk value might give better performance if your elements are too cheap to get a benefit evaluating each one in parallel (because it saves on sparking for each element).EDIT: Based on your question I feel I should explain why this is an answer. It's because Haskell is lazy! Consider the statement
Nothing has been evaluated. You've just created a thunk that maps
expensiveFunction
. So how do we evaluate it in parallel?Now don't use the
bs
list in your future computations, instead use thecs
list. IOW, you don't need a parallel map, you can use the regular (lazy) maps and a parallel evaulation strategy.EDIT: And if you look around enough you'll see the parMap function that does what I showed here but wrapped into one helper function.
In response to your comment, does the below code not work for you? it works for me.