![](haskell_icon.gif) | dph-prim-par-0.3: Parallel Primitives for Data-Parallel Haskell. | Contents | Index |
|
Data.Array.Parallel.Unlifted.Distributed | Portability | non-portable (GHC Extensions) | Stability | experimental | Maintainer | Roman Leshchinskiy <rl@cse.unsw.edu.au> |
|
|
|
|
|
Description |
Distributed types and operations.
|
|
Synopsis |
|
data Gang | | forkGang :: Int -> IO Gang | | gangSize :: Gang -> Int | | sequentialGang :: Int -> Gang | | seqGang :: Gang -> Gang | | theGang :: Gang | | class DT a | | data Dist a | | mapD :: (DT a, DT b) => Gang -> (a -> b) -> Dist a -> Dist b | | zipWithD :: (DT a, DT b, DT c) => Gang -> (a -> b -> c) -> Dist a -> Dist b -> Dist c | | foldD :: DT a => Gang -> (a -> a -> a) -> Dist a -> a | | scanD :: DT a => Gang -> (a -> a -> a) -> a -> Dist a -> Dist a :*: a | | eqD :: (Eq a, DT a) => Gang -> Dist a -> Dist a -> Bool | | neqD :: (Eq a, DT a) => Gang -> Dist a -> Dist a -> Bool | | scalarD :: DT a => Gang -> a -> Dist a | | andD :: Gang -> Dist Bool -> Bool | | orD :: Gang -> Dist Bool -> Bool | | sumD :: (Num a, DT a) => Gang -> Dist a -> a | | zipD :: (DT a, DT b) => Dist a -> Dist b -> Dist (a :*: b) | | unzipD :: (DT a, DT b) => Dist (a :*: b) -> Dist a :*: Dist b | | fstD :: (DT a, DT b) => Dist (a :*: b) -> Dist a | | sndD :: (DT a, DT b) => Dist (a :*: b) -> Dist b | | lengthD :: UA a => Dist (UArr a) -> Dist Int | | splitLenD :: Gang -> Int -> Dist Int | | splitLengthD :: UA a => Gang -> UArr a -> Dist Int | | splitD :: UA a => Gang -> Distribution -> UArr a -> Dist (UArr a) | | joinLengthD :: UA a => Gang -> Dist (UArr a) -> Int | | joinD :: UA a => Gang -> Distribution -> Dist (UArr a) -> UArr a | | splitJoinD :: (UA a, UA b) => Gang -> (Dist (UArr a) -> Dist (UArr b)) -> UArr a -> UArr b | | data Distribution | | balanced :: Distribution | | unbalanced :: Distribution | | permuteD :: UA a => Gang -> Dist (UArr a) -> Dist (UArr Int) -> UArr a | | bpermuteD :: UA a => Gang -> UArr a -> Dist (UArr Int) -> Dist (UArr a) | | atomicUpdateD :: UA a => Gang -> Dist (UArr a) -> Dist (UArr (Int :*: a)) -> UArr a | | bpermuteSD' :: UA a => Gang -> UArr a -> Dist (SUArr Int) -> Dist (SUArr a) | | splitSD :: UA a => Gang -> Distribution -> SUArr a -> Dist (SUArr a) | | joinSD :: UA a => Gang -> Distribution -> Dist (SUArr a) -> SUArr a | | splitJoinSD :: (UA a, UA b) => Gang -> (Dist (SUArr a) -> Dist (SUArr b)) -> SUArr a -> SUArr b | | fromD :: DT a => Gang -> Dist a -> [a] | | toD :: DT a => Gang -> [a] -> Dist a |
|
|
|
Gang operations
|
|
data Gang |
A Gang is a either group of threads which execute arbitrary work
requests. A sequential Gang simulates such a group by executing work
requests sequentially.
| Instances | |
|
|
forkGang :: Int -> IO Gang |
Fork a Gang with the given number of threads (at least 1).
|
|
gangSize :: Gang -> Int |
The number of threads in the Gang.
|
|
sequentialGang :: Int -> Gang |
Yield a sequential Gang which simulates the given number of threads.
|
|
seqGang :: Gang -> Gang |
Yield a sequential Gang which simulates the given one.
|
|
Gang hacks
|
|
theGang :: Gang |
|
Distributed types and classes
|
|
class DT a |
Distributed types
----------------------------
Class of distributable types. Instances of DT can be
distributed across all workers of a Gang. All such types
must be hyperstrict as we do not want to pass thunks into distributed
computations.
| | Instances | |
|
|
data Dist a |
Instances | |
|
|
Higher-order combinators
|
|
mapD :: (DT a, DT b) => Gang -> (a -> b) -> Dist a -> Dist b |
Map a function over a distributed value.
|
|
zipWithD :: (DT a, DT b, DT c) => Gang -> (a -> b -> c) -> Dist a -> Dist b -> Dist c |
Combine two distributed values with the given function.
|
|
foldD :: DT a => Gang -> (a -> a -> a) -> Dist a -> a |
Fold a distributed value.
|
|
scanD :: DT a => Gang -> (a -> a -> a) -> a -> Dist a -> Dist a :*: a |
Prefix sum of a distributed value.
|
|
Equality
|
|
eqD :: (Eq a, DT a) => Gang -> Dist a -> Dist a -> Bool |
Test whether to distributed values are equal. This requires a Gang
and hence can't be defined in terms of Eq.
|
|
neqD :: (Eq a, DT a) => Gang -> Dist a -> Dist a -> Bool |
Test whether to distributed values are not equal. This requires a Gang
and hence can't be defined in terms of Eq.
|
|
Distributed scalars
|
|
scalarD :: DT a => Gang -> a -> Dist a |
Distribute a scalar.
|
|
andD :: Gang -> Dist Bool -> Bool |
|
orD :: Gang -> Dist Bool -> Bool |
|
sumD :: (Num a, DT a) => Gang -> Dist a -> a |
|
Distributed pairs
|
|
zipD :: (DT a, DT b) => Dist a -> Dist b -> Dist (a :*: b) |
Pairing of distributed values.
The two values must belong to the same Gang.
|
|
unzipD :: (DT a, DT b) => Dist (a :*: b) -> Dist a :*: Dist b |
Unpairing of distributed values.
|
|
fstD :: (DT a, DT b) => Dist (a :*: b) -> Dist a |
Extract the first elements of a distributed pair.
|
|
sndD :: (DT a, DT b) => Dist (a :*: b) -> Dist b |
Extract the second elements of a distributed pair.
|
|
Distributed arrays
|
|
lengthD :: UA a => Dist (UArr a) -> Dist Int |
Yield the distributed length of a distributed array.
|
|
splitLenD :: Gang -> Int -> Dist Int |
Distribute the given array length over a Gang.
|
|
splitLengthD :: UA a => Gang -> UArr a -> Dist Int |
Distribute the length of an array over a Gang.
|
|
splitD :: UA a => Gang -> Distribution -> UArr a -> Dist (UArr a) |
Distribute an array over a Gang.
|
|
joinLengthD :: UA a => Gang -> Dist (UArr a) -> Int |
Overall length of a distributed array.
|
|
joinD :: UA a => Gang -> Distribution -> Dist (UArr a) -> UArr a |
Join a distributed array.
|
|
splitJoinD :: (UA a, UA b) => Gang -> (Dist (UArr a) -> Dist (UArr b)) -> UArr a -> UArr b |
|
data Distribution |
|
balanced :: Distribution |
|
unbalanced :: Distribution |
|
Permutations
|
|
permuteD :: UA a => Gang -> Dist (UArr a) -> Dist (UArr Int) -> UArr a |
Permute for distributed arrays.
|
|
bpermuteD :: UA a => Gang -> UArr a -> Dist (UArr Int) -> Dist (UArr a) |
|
atomicUpdateD :: UA a => Gang -> Dist (UArr a) -> Dist (UArr (Int :*: a)) -> UArr a |
|
bpermuteSD' :: UA a => Gang -> UArr a -> Dist (SUArr Int) -> Dist (SUArr a) |
|
Distributed segmented arrays
|
|
splitSD :: UA a => Gang -> Distribution -> SUArr a -> Dist (SUArr a) |
|
joinSD :: UA a => Gang -> Distribution -> Dist (SUArr a) -> SUArr a |
|
splitJoinSD :: (UA a, UA b) => Gang -> (Dist (SUArr a) -> Dist (SUArr b)) -> SUArr a -> SUArr b |
|
Debugging
|
|
fromD :: DT a => Gang -> Dist a -> [a] |
Yield all elements of a distributed value.
NOTE: Debugging only.
|
|
toD :: DT a => Gang -> [a] -> Dist a |
Generate a distributed value from the first p elements of a list.
NOTE: Debugging only.
|
|
Produced by Haddock version 2.3.0 |