Data.Array.Parallel.Lifted

Documentation

data PArray a

Lifted/bulk parallel arrays This contains the array length, along with the element data.

Constructors

PArray Int# (PData a)

Instances

(PA a, Show a) => Show (PArray a)

PR a => PR (PArray a)

PA a => PA (PArray a)

data family PData a

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 where

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).

Methods

toPRepr :: a -> PRepr a

fromPRepr :: PRepr a -> a

toArrPRepr :: PData a -> PData (PRepr a)

fromArrPRepr :: PData (PRepr a) -> PData a

Instances

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)

lengthPA# :: PArray a -> Int#

Take the length field of a PArray.

dataPA# :: PArray a -> PData a

Take the data field of a PArray.

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

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.

class PR a where

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.

Methods

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

Instances

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)

class Elt a => Scalar a where

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.

Methods

fromScalarPData :: PData a -> Array a

toScalarPData :: Array a -> PData a

Instances

Scalar Bool

Scalar Double

Scalar Float

Scalar Int

Scalar Word8

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

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.

Instances

PR (:-> a b)

(PA a, PA b) => PA (:-> a b)

($:) :: forall a b. (a :-> b) -> a -> b

Apply a closure to its argument.

($:^) :: forall a b. PArray (a :-> b) -> PArray a -> PArray b

Lifted closure application

fromPArrayPA :: PA a => PArray a :-> PArray a

toPArrayPA :: PA a => PArray a :-> PArray a

fromNestedPArrayPA :: PA a => PArray (PArray a) :-> PArray (PArray a)