{-# LANGUAGE CPP, FlexibleContexts #-} #include "fusion-phases.h" -- | Defines the family of types that can be represented generically, -- and the functions to convert two and from the generic representation. -- -- TODO: Check inconsistent use of INLINE pragmas. -- Most have INLINE_PA, but bpermutePD and nfPD have plain INLINE -- module Data.Array.Parallel.PArray.PRepr ( PRepr, PA(..), -- These functions have corresponding members in the PR class -- from Data.Array.Parallel.PArray.PData. emptyPD, replicatePD, replicatelPD, repeatPD, indexPD, extractPD, bpermutePD, appPD, applPD, packByTagPD, combine2PD, updatePD, fromListPD, nfPD ) where import Data.Array.Parallel.PArray.PData -- | 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. -- type family PRepr a -- | 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). -- 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 -- These methods aren't used in this backend, but the vecoriser expects -- them to be part of the PA class. It will generate instances for them, -- but they will never be called at runtime. toArrPReprs :: PDatas a -> PDatas (PRepr a) fromArrPReprs :: PDatas (PRepr a) -> PDatas a -- PD Wrappers ---------------------------------------------------------------- -- These wrappers work on (PData a) arrays when we know the element type 'a' -- is representable. For most of them we can just convert the PData to the -- underlying representation type, and use the corresponding operator from -- the PR dictionary. -- emptyPD :: PA a => T_emptyPR a {-# INLINE_PA emptyPD #-} emptyPD = fromArrPRepr emptyPR replicatePD :: PA a => T_replicatePR a {-# INLINE_PA replicatePD #-} replicatePD n# x = fromArrPRepr . replicatePR n# $ toPRepr x replicatelPD :: PA a => T_replicatelPR a {-# INLINE_PA replicatelPD #-} replicatelPD segd xs = fromArrPRepr . replicatelPR segd $ toArrPRepr xs repeatPD :: PA a => T_repeatPR a {-# INLINE_PA repeatPD #-} repeatPD n# len# xs = fromArrPRepr . repeatPR n# len# $ toArrPRepr xs indexPD :: PA a => T_indexPR a {-# INLINE_PA indexPD #-} indexPD xs i# = fromPRepr $ indexPR (toArrPRepr xs) i# extractPD :: PA a => T_extractPR a {-# INLINE_PA extractPD #-} extractPD xs i# m# = fromArrPRepr $ extractPR (toArrPRepr xs) i# m# bpermutePD :: PA a => T_bpermutePR a {-# INLINE bpermutePD #-} bpermutePD xs n# is = fromArrPRepr $ bpermutePR (toArrPRepr xs) n# is appPD :: PA a => T_appPR a {-# INLINE_PA appPD #-} appPD xs ys = fromArrPRepr $ appPR (toArrPRepr xs) (toArrPRepr ys) applPD :: PA a => T_applPR a {-# INLINE_PA applPD #-} applPD segd is xs js ys = fromArrPRepr $ applPR segd is (toArrPRepr xs) js (toArrPRepr ys) packByTagPD :: PA a => T_packByTagPR a {-# INLINE_PA packByTagPD #-} packByTagPD xs n# tags t# = fromArrPRepr $ packByTagPR (toArrPRepr xs) n# tags t# combine2PD :: PA a => T_combine2PR a {-# INLINE_PA combine2PD #-} combine2PD n# sel as bs = fromArrPRepr $ combine2PR n# sel (toArrPRepr as) (toArrPRepr bs) updatePD :: PA a => T_updatePR a {-# INLINE_PA updatePD #-} updatePD xs is ys = fromArrPRepr $ updatePR (toArrPRepr xs) is (toArrPRepr ys) fromListPD :: PA a => T_fromListPR a {-# INLINE_PA fromListPD #-} fromListPD n# xs = fromArrPRepr $ fromListPR n# (map toPRepr xs) nfPD :: PA a => T_nfPR a {-# INLINE nfPD #-} nfPD xs = nfPR (toArrPRepr xs)