Personal tools

Concurrency demos/Zeta

From HaskellWiki

< Concurrency demos(Difference between revisions)
Jump to: navigation, search
Line 38: Line 38:
 
results <- mapM takeMVar childs
 
results <- mapM takeMVar childs
 
print (sum results)
 
print (sum results)
where
+
where
thread s range = do
+
thread s range = do
putStrLn ("Starting thread for range " ++ show range)
+
putStrLn ("Starting thread for range " ++ show range)
mvar <- newEmptyMVar
+
mvar <- newEmptyMVar
forkIO (putMVar mvar (zetaRange s range))
+
forkIO (putMVar mvar (zetaRange s range))
return mvar
+
return mvar
 
</haskell>
 
</haskell>
   

Revision as of 21:15, 28 November 2006

Contents


1 A simple example of parallelism in Haskell

This little piece of code computes an approximation of Riemann's zeta function, balancing the work to be done between N threads.

import Control.Concurrent
import Control.Concurrent.MVar
import Control.Monad
import Data.Complex
import System.Environment
 
 
zetaRange :: (Floating a, Integral b) => a -> (b, b) -> a
zetaRange s (x,y) = sum [ (fromIntegral n) ** (-s) | n <- [x..y] ]
 
cut :: (Integral a) => (a, a) -> a -> [(a, a)]
cut (x,y) n = (x, x + mine - 1) : cut' (x + mine) size (y - mine)
 where
  (size, modulo)   = y `divMod` n
  mine             = size + modulo
 
  cut' _ _ 0       = []
  cut' x' size' n' = (x', x' + size' - 1) : cut' (x' + size') size' (n' - size') 
 
getParams :: IO (Int, Int, Complex Double)
getParams = do
  argv <- getArgs
  case argv of
    (t:n:s:[]) -> return (read t, read n, read s)
    _          -> error "usage: zeta <nthreads> <boundary> <s>"
 
main :: IO ()
main = do
  (t, n, s) <- getParams
  childs    <- zipWithM thread (repeat s) (cut (1, n) t)
  results   <- mapM takeMVar childs
  print (sum results)
 where
  thread s range = do
    putStrLn ("Starting thread for range " ++ show range)
    mvar <- newEmptyMVar
    forkIO (putMVar mvar (zetaRange s range))
    return mvar


2 Benchmarks

Insert benchmarks here! :-)