Control.CUtils.Conc

A module of concurrent higher order functions.

Documentation

module Control.CUtils.ThreadPool

data ExceptionList

For exceptions caused by caller code.

Constructors

ExceptionList [SomeException]

Instances

Show ExceptionList

Methods

showsPrec :: Int -> ExceptionList -> ShowS

show :: ExceptionList -> String

showList :: [ExceptionList] -> ShowS

Exception ExceptionList

Methods

toException :: ExceptionList -> SomeException

fromException :: SomeException -> Maybe ExceptionList

displayException :: ExceptionList -> String

data ConcException

For internal errors. If a procedure throws this, some threads it created may still be running. It is thrown separately from ExceptionList.

Constructors

ConcException

Instances

Show ConcException

Methods

showsPrec :: Int -> ConcException -> ShowS

show :: ConcException -> String

showList :: [ConcException] -> ShowS

Exception ConcException

Methods

toException :: ConcException -> SomeException

fromException :: SomeException -> Maybe ConcException

displayException :: ConcException -> String

assocFold :: (?pool :: BoxedThreadPool, Concurrent (Kleisli m)) => (b -> b -> m b) -> (c -> b) -> (b, Array Int c) -> m b

class Concurrent a where

A type class of arrows that support some form of concurrency.

Minimal complete definition

arr_assocFold, arr_concF_, arr_concF, arr_oneOfF

Methods

arr_assocFold :: (?pool :: BoxedThreadPool) => a (b, b) b -> (c -> b) -> a (b, Array Int c) b

Runs an associative folding function on the given array. Note: this function only spawns enough threads to make effective use of the capabilities. Any two list elements may be processed sequentially or concurrently. To get parallelism, you have to set the numCapabilities value, e.g. using GHC's +RTS -N flag.

arr_concF_ :: (?seq :: Bool, ?pool :: BoxedThreadPool) => a (t, Int) () -> a (t, Int) ()

The first parameter is the number of computations which are indexed from 0 to n - 1.

arr_concF :: (?seq :: Bool, ?pool :: BoxedThreadPool) => a (u, Int) t -> a (u, Int) (Array Int t)

arr_oneOfF :: a (u, Int) b -> a (u, Int) b

Instances

Concurrent (->)

Methods

arr_assocFold :: (?pool :: BoxedThreadPool) => ((b, b) -> b) -> (c -> b) -> (b, Array Int c) -> b

arr_concF_ :: (?seq :: Bool, ?pool :: BoxedThreadPool) => ((t, Int) -> ()) -> (t, Int) -> ()

arr_concF :: (?seq :: Bool, ?pool :: BoxedThreadPool) => ((u, Int) -> t) -> (u, Int) -> Array Int t

arr_oneOfF :: ((u, Int) -> b) -> (u, Int) -> b

Concurrent (Kleisli IO)

Methods

arr_assocFold :: (?pool :: BoxedThreadPool) => Kleisli IO (b, b) b -> (c -> b) -> Kleisli IO (b, Array Int c) b

arr_concF_ :: (?seq :: Bool, ?pool :: BoxedThreadPool) => Kleisli IO (t, Int) () -> Kleisli IO (t, Int) ()

arr_concF :: (?seq :: Bool, ?pool :: BoxedThreadPool) => Kleisli IO (u, Int) t -> Kleisli IO (u, Int) (Array Int t)

arr_oneOfF :: Kleisli IO (u, Int) b -> Kleisli IO (u, Int) b

concF_ :: (?seq :: Bool, ?pool :: BoxedThreadPool, Concurrent (Kleisli m)) => Int -> (Int -> m ()) -> m ()

concF :: (?seq :: Bool, ?pool :: BoxedThreadPool, Concurrent (Kleisli m)) => Int -> (Int -> m t) -> m (Array Int t)

conc_ :: (?seq :: Bool, ?pool :: BoxedThreadPool, Concurrent (Kleisli m)) => Array Int (m ()) -> m ()

conc :: (?seq :: Bool, ?pool :: BoxedThreadPool) => Array Int (IO e) -> IO (Array Int e)

The next function takes an implicit parameter ?seq. Set it to True if you want to only spawn threads for the capabilities (same as assocFold; good for speed). If you need all the actions to be executed concurrently, set it to False.

concP :: (Concurrent (Kleisli m), ?pool :: BoxedThreadPool, Monad m) => m t1 -> m t -> m (t1, t)

Version of concF specialized for two computations.

progressConcF :: (?seq :: Bool, ?pool :: BoxedThreadPool) => Int -> (Int -> IO t) -> IO (Array Int t)

oneOfF :: Concurrent (Kleisli m) => Int -> (Int -> m b) -> m b

oneOf :: Array Int (IO a) -> IO a

Runs several computations in parallel, and returns one of their results (terminating the other computations).