
Data.Array.Parallel.Unlifted.Distributed  Portability  nonportable (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 where    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)   splitAsD :: UA a => Gang > Dist Int > 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   splitSegdD :: Gang > USegd > Dist USegd   splitSD :: UA a => Gang > Dist USegd > UArr a > Dist (UArr a)   lengthUSegdD :: Dist USegd > Dist Int   lengthsUSegdD :: Dist USegd > Dist (UArr Int)   indicesUSegdD :: Dist USegd > Dist (UArr Int)   elementsUSegdD :: Dist USegd > Dist Int   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   fromD :: DT a => Gang > Dist a > [a]   toD :: DT a => Gang > [a] > Dist a 



Gang operations



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  



Fork a Gang with the given number of threads (at least 1).



The number of threads in the Gang.



Yield a sequential Gang which simulates the given number of threads.



Yield a sequential Gang which simulates the given one.


Gang hacks




Distributed types and classes



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.
  Associated Types    Methods    Instances  


Higherorder combinators



Map a function over a distributed value.



Combine two distributed values with the given function.



Fold a distributed value.



Prefix sum of a distributed value.


Equality



Test whether to distributed values are equal. This requires a Gang
and hence can't be defined in terms of Eq.



Test whether to distributed values are not equal. This requires a Gang
and hence can't be defined in terms of Eq.


Distributed scalars



Distribute a scalar.








Distributed pairs



Pairing of distributed values.
The two values must belong to the same Gang.



Unpairing of distributed values.



Extract the first elements of a distributed pair.



Extract the second elements of a distributed pair.


Distributed arrays



Yield the distributed length of a distributed array.



Distribute the given array length over a Gang.



Distribute the length of an array over a Gang.



Distribute an array over a Gang.



Distribute an array over a Gang such that each threads gets the given
number of elements.



Overall length of a distributed array.



Join a distributed array.






















Permutations



Permute for distributed arrays.






Debugging



Yield all elements of a distributed value.
NOTE: Debugging only.



Generate a distributed value from the first p elements of a list.
NOTE: Debugging only.


Produced by Haddock version 2.6.1 