Safe Haskell | Safe-Infered |
---|
- data PArray a = PArray Int# (PData a)
- data family PData a
- class PR (PRepr a) => PA a where
- toPRepr :: a -> PRepr a
- fromPRepr :: PRepr a -> a
- toArrPRepr :: PData a -> PData (PRepr a)
- fromArrPRepr :: PData (PRepr a) -> PData a
- toArrPReprs :: PDatas a -> PDatas (PRepr a)
- fromArrPReprs :: PDatas (PRepr a) -> PDatas a
- lengthPA# :: PArray a -> Int#
- dataPA# :: PArray a -> PData a
- replicatePA# :: PA a => Int# -> a -> PArray a
- replicatelPA# :: PA a => Segd -> PArray a -> PArray a
- repeatPA# :: PA a => Int# -> PArray a -> PArray a
- emptyPA :: PA a => PArray a
- indexPA# :: PA a => PArray a -> Int# -> a
- extractPA# :: PA a => PArray a -> Int# -> Int# -> PArray a
- bpermutePA# :: PA a => PArray a -> Int# -> Array Int -> PArray a
- appPA# :: PA a => PArray a -> PArray a -> PArray a
- applPA# :: PA a => Segd -> Segd -> PArray a -> Segd -> PArray a -> PArray a
- packByTagPA# :: PA a => PArray a -> Int# -> Array Tag -> Int# -> PArray a
- combine2PA# :: PA a => Int# -> Sel2 -> PArray a -> PArray a -> PArray a
- updatePA# :: PA a => PArray a -> Array Int -> PArray a -> PArray a
- fromListPA# :: PA a => Int# -> [a] -> PArray a
- fromListPA :: PA a => [a] -> PArray a
- nfPA :: PA a => PArray a -> ()
- replicatePD :: PA a => T_replicatePR a
- replicatelPD :: PA a => T_replicatelPR a
- repeatPD :: PA a => T_repeatPR a
- emptyPD :: PA a => T_emptyPR a
- indexPD :: PA a => T_indexPR a
- extractPD :: PA a => T_extractPR a
- bpermutePD :: PA a => T_bpermutePR a
- appPD :: PA a => T_appPR a
- applPD :: PA a => T_applPR a
- packByTagPD :: PA a => T_packByTagPR a
- combine2PD :: PA a => T_combine2PR a
- updatePD :: PA a => T_updatePR a
- fromListPD :: PA a => T_fromListPR a
- nfPD :: PA a => T_nfPR a
- type family PRepr a
- class PR a where
- emptyPR :: T_emptyPR a
- replicatePR :: T_replicatePR a
- replicatelPR :: T_replicatelPR a
- repeatPR :: T_repeatPR a
- indexPR :: T_indexPR a
- extractPR :: T_extractPR a
- bpermutePR :: T_bpermutePR a
- appPR :: T_appPR a
- applPR :: T_applPR a
- packByTagPR :: T_packByTagPR a
- combine2PR :: T_combine2PR a
- updatePR :: T_updatePR a
- fromListPR :: T_fromListPR a
- nfPR :: T_nfPR a
- class Elt a => Scalar a where
- fromScalarPData :: PData a -> Array a
- toScalarPData :: Array a -> PData a
- replicatePRScalar :: Scalar a => T_replicatePR a
- replicatelPRScalar :: Scalar a => T_replicatelPR a
- repeatPRScalar :: Scalar a => T_repeatPR a
- emptyPRScalar :: Scalar a => T_emptyPR a
- indexPRScalar :: Scalar a => T_indexPR a
- extractPRScalar :: Scalar a => T_extractPR a
- bpermutePRScalar :: Scalar a => T_bpermutePR a
- appPRScalar :: Scalar a => T_appPR a
- applPRScalar :: Scalar a => T_applPR a
- packByTagPRScalar :: Scalar a => T_packByTagPR a
- combine2PRScalar :: Scalar a => T_combine2PR a
- updatePRScalar :: Scalar a => T_updatePR a
- fromListPRScalar :: Scalar a => T_fromListPR a
- nfPRScalar :: Scalar a => T_nfPR a
- data a :-> b
- ($:) :: forall a b. (a :-> b) -> a -> b
- ($:^) :: forall a b. PArray (a :-> b) -> PArray a -> PArray b
- fromPArrayPA :: PA a => PArray a :-> PArray a
- toPArrayPA :: PA a => PArray a :-> PArray a
- fromNestedPArrayPA :: PA a => PArray (PArray a) :-> PArray (PArray a)
Documentation
Lifted/bulk parallel arrays This contains the array length, along with the element data.
Parallel Data. This is the family of types that store parallel array data.
PData takes the type of an element and produces the type we use to store an array of those elements. The instances for PData use an efficient representation that depends on the type of elements being stored. For example, an array of pairs is stored as two separate arrays, one for each element type. This lets us avoid storing the intermediate Pair/Tuple constructors and the pointers to the elements.
Most of the instances are defined in Data.Array.Parallel.PArray.Instances, though the instances for function closures are defined in their own module, Data.Array.Parallel.Lifted.Closure.
Note that PData is just a flat chunk of memory containing elements, and doesn't include a field giving the length of the array. We use PArray when we want to pass around the array data along with its length.
class PR (PRepr a) => PA a whereSource
A PA dictionary contains the functions that we use to convert a representable type to and from its generic representation. The conversion methods should all be O(1).
fromPRepr :: PRepr a -> aSource
toArrPRepr :: PData a -> PData (PRepr a)Source
fromArrPRepr :: PData (PRepr a) -> PData aSource
toArrPReprs :: PDatas a -> PDatas (PRepr a)Source
fromArrPReprs :: PDatas (PRepr a) -> PDatas aSource
PA Bool | |
PA Double | |
PA Float | |
PA Int | |
PA Word8 | |
PA () | |
PA Void | |
PA a => PA (PArray a) | |
(PA a, PA b) => PA (a, b) | |
(PA a, PA b) => PA (:-> a b) | |
(PA a, PA b, PA c) => PA (a, b, c) | |
(PA a, PA b, PA c, PA d) => PA (a, b, c, d) | |
(PA a, PA b, PA c, PA d, PA e) => PA (a, b, c, d, e) | |
(PA a, PA b, PA c, PA d, PA e, PA f) => PA (a, b, c, d, e, f) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g) => PA (a, b, c, d, e, f, g) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h) => PA (a, b, c, d, e, f, g, h) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i) => PA (a, b, c, d, e, f, g, h, i) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j) => PA (a, b, c, d, e, f, g, h, i, j) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k) => PA (a, b, c, d, e, f, g, h, i, j, k) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l) => PA (a, b, c, d, e, f, g, h, i, j, k, l) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m, PA n) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h, PA i, PA j, PA k, PA l, PA m, PA n, PA o) => PA (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
replicatePA# :: PA a => Int# -> a -> PArray aSource
fromListPA# :: PA a => Int# -> [a] -> PArray aSource
fromListPA :: PA a => [a] -> PArray aSource
replicatePD :: PA a => T_replicatePR aSource
replicatelPD :: PA a => T_replicatelPR aSource
bpermutePD :: PA a => T_bpermutePR aSource
packByTagPD :: PA a => T_packByTagPR aSource
combine2PD :: PA a => T_combine2PR aSource
fromListPD :: PA a => T_fromListPR aSource
Representable types.
The family of types that we know how to represent generically. PRepr takes an arbitrary type and produces the generic type we use to represent it.
Instances for simple types are defined in Data.Array.Parallel.Lifted.Instances. For algebraic types, it's up to the vectoriser/client module to create a suitable instance.
A PR dictionary contains the primitive functions that operate directly on parallel array data.
It's called PR because the functions work on our internal, efficient Representation of the user-level array.
replicatePR :: T_replicatePR aSource
replicatelPR :: T_replicatelPR aSource
repeatPR :: T_repeatPR aSource
extractPR :: T_extractPR aSource
bpermutePR :: T_bpermutePR aSource
packByTagPR :: T_packByTagPR aSource
combine2PR :: T_combine2PR aSource
updatePR :: T_updatePR aSource
fromListPR :: T_fromListPR aSource
PR Double | |
PR Float | |
PR Int | |
PR Word8 | |
PR () | |
PR Void | |
PA a => PR (Wrap a) | |
PR a => PR (PArray a) | |
(PR a, PR b) => PR (a, b) | |
(PR a, PR b) => PR (Sum2 a b) | |
PR (:-> a b) | |
(PR a, PR b, PR c) => PR (a, b, c) | |
(PR a, PR b, PR c, PR d) => PR (a, b, c, d) | |
(PR a, PR b, PR c, PR d, PR e) => PR (a, b, c, d, e) | |
(PR a, PR b, PR c, PR d, PR e, PR f) => PR (a, b, c, d, e, f) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g) => PR (a, b, c, d, e, f, g) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h) => PR (a, b, c, d, e, f, g, h) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i) => PR (a, b, c, d, e, f, g, h, i) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j) => PR (a, b, c, d, e, f, g, h, i, j) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j, PR k) => PR (a, b, c, d, e, f, g, h, i, j, k) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j, PR k, PR l) => PR (a, b, c, d, e, f, g, h, i, j, k, l) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j, PR k, PR l, PR m) => PR (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j, PR k, PR l, PR m, PR n) => PR (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
(PR a, PR b, PR c, PR d, PR e, PR f, PR g, PR h, PR i, PR j, PR k, PR l, PR m, PR n, PR o) => PR (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) |
class Elt a => Scalar a whereSource
Class of scalar types. Scalar types are the ones that we can store in our underlying U.Arrays (which are currently implemented as Data.Vectors).
To perform an operation on a PData array of scalar elements, we coerce it to the underling U.Array and use the corresponding U.Array operators.
fromScalarPData :: PData a -> Array aSource
toScalarPData :: Array a -> PData aSource
replicatePRScalar :: Scalar a => T_replicatePR aSource
replicatelPRScalar :: Scalar a => T_replicatelPR aSource
repeatPRScalar :: Scalar a => T_repeatPR aSource
emptyPRScalar :: Scalar a => T_emptyPR aSource
indexPRScalar :: Scalar a => T_indexPR aSource
extractPRScalar :: Scalar a => T_extractPR aSource
bpermutePRScalar :: Scalar a => T_bpermutePR aSource
appPRScalar :: Scalar a => T_appPR aSource
applPRScalar :: Scalar a => T_applPR aSource
packByTagPRScalar :: Scalar a => T_packByTagPR aSource
combine2PRScalar :: Scalar a => T_combine2PR aSource
updatePRScalar :: Scalar a => T_updatePR aSource
fromListPRScalar :: Scalar a => T_fromListPR aSource
nfPRScalar :: Scalar a => T_nfPR aSource
The type of closures. This bundles up: 1) the vectorised version of the function that takes an explicit environment 2) the lifted version, that works on arrays. the first parameter of this function is the 'lifting context' that gives the length of the array. 3) the environment of the closure.
The vectoriser closure-converts the source program so that all functions types are expressed in this form.