Parallelism in simple prime search function - haskell

Question

I am trying to learn concurrency and parallelism in Haskell.
And I just started Simon Marlow's book. Not everything is clear though.
And there aren't many (if any) simple examples on the internet.
This is just a simple prime search function for learning purposes.
Can this be parallelised? And if yes, can someone show an example with this function.
main = mapM_ print [x | x <- [2..], isPrime x]
isPrime :: Integer -> Bool
isPrime n = odd n && all (\ f -> n `mod` f /= 0) [3..(ceiling $ sqrt $ fromIntegral n)]
I understand that I can use Strategies to map through a list in parallel.
How, for instance, would I test factors in the list in batches of 8, doing 8 tests in parallel?
I would love an example please.
Thanks.

Answer 1

This answer is also available as a .lhs file at http://lpaste.net/143207
The basic idea is that whenever you have an expression like:
map f xs
you can replace it with:
parMap strat f xs
to spawn off the map computation as sparks so that it will
be executed in parallel in the threaded runtime.
A typical choice for strat is rdeepseq - see Basic Strategies for other options.
The problem is that spawning every single call to f as
a spark may not be cost effective. To realize any speedup
you may have to organize the work so that a spark is responsible
for calling f on a range of elements of the list.
Let's write isPrime like this:
-- original version
isPrime0 n = and $ map notfactor [2..limit]
where limit = div n 2
notfactor f = mod n f /= 0
(I've purposely extended the factor testing range so we don't
have to use large prime numbers for our tests.)
The first idea would be to simply change the map into parMap rdeepseq:
-- spawn each call to notfactor as a spark
isPrime1 n = and $ parMap rdeepseq notfactor [2..limit]
where limit = div n 2
notfactor f = mod n f /= 0
If you benchmark this, however, you'll find
out this runs a lot slower than the sequential version.
The next idea is to break up the range [2..limit] into
a small number of chunks like this:
-- evaluate the notfactor calls in ranges -- not parallized
isPrime2 n = and $ map (\r -> all notfactor r) ranges
where limit = div n 2 -- ceiling $ sqrt $ fromIntegral n
notfactor f = mod n f /= 0
ranges = chunks 3 limit 10
Here chunks a b k is a function which splits the
list [a..b] into k equal sized ranges.
To get a parallized version, we change the map call
into parMap rdeepseq:
-- evaluate the notfacto calls in ranges - parallelized
isPrime3 n = and $ parMap rdeepseq (\r -> all notfactor r) ranges
where limit = div n 2
notfactor f = mod n f /= 0
ranges = chunks 3 limit 10
Some rough timings (in seconds) for the prime 15485863 and
RTS option -N1 vs. -N2:
-N1 -N2
isPrime0 0.624 0.673
isPrime1 12.--- 12.---
isPrime2 0.573 0.603
isPrime3 0.563 0.365
As you can see, isPrime3 does exhibit some speedup. The timing for isPrime1 is due to the fact that it is creating several million sparks compared to isPrime3 which only creates 10 sparks.
For completeness, here's the code for chunks and the
program driver.
-- divide a range into equal size chunks
chunks :: Integer -> Integer -> Integer -> [[Integer]]
chunks a b k =
let (q,r) = divMod (b - a) k
sizes = replicate (fromIntegral r) (q+1) ++ replicate (fromIntegral (k-r)) q
go x [] = []
go x (y:ys) = [x..x+y-1] : go (x+y) ys
in go a sizes
main :: IO ()
main = do
( which : ps : _ ) <- getArgs
let p = read ps
case which of
"0" -> print $ isPrime0 p
"1" -> print $ isPrime1 p
"2" -> print $ isPrime2 p
"3" -> print $ isPrime3 p