Split out PRepr and PA class into its own module
authorBen Lippmeier <benl@ouroborus.net>
Thu, 5 May 2011 06:10:39 +0000 (16:10 +1000)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 9 May 2011 07:40:08 +0000 (17:40 +1000)
dph-common/Data/Array/Parallel/Lifted/PArray.hs
dph-common/Data/Array/Parallel/Lifted/Repr.hs
dph-common/Data/Array/Parallel/PArray/PData.hs
dph-common/Data/Array/Parallel/PArray/PRepr.hs [new file with mode: 0644]
dph-common/Data/Array/Parallel/PArray/Scalar.hs
dph-common/dph-common.cabal

index 15afdcb..ad1bac8 100644 (file)
@@ -34,8 +34,9 @@ module Data.Array.Parallel.Lifted.PArray (
 import qualified Data.Array.Parallel.Unlifted as U
 import Data.Array.Parallel.Lifted.Unboxed ( elementsSegd# )
 import Data.Array.Parallel.Base           ( Tag, intToTag, traceF )
-import Data.Array.Parallel.PArray.PData
+import Data.Array.Parallel.PArray.PRepr
 import Data.Array.Parallel.PArray.Scalar
+import Data.Array.Parallel.PArray.PData
 import GHC.Exts (Int#, Int(..), (+#), (*#))
 import SpecConstr
 
@@ -47,120 +48,10 @@ import SpecConstr
 data PArray a = PArray Int# (PData 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 client module to provide a suitable instance.
---
-type family PRepr a
 
 
 -- Dictionaries -----------------------------------------------------------------------------------
 
--- |A PA dictionary contains the functions that we use to convert a
---  representable type to its generic representation, and back.
---
-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
-
-
--- PD Wrappers ------------------------------------------------------------------------------------
---
---   Given some data that has a PA dictionary, we can convert it to its generic representation
---   type, perform the requested operation, then convert it back.
---
-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)
-
-
 -- PA Wrappers ------------------------------------------------------------------------------------
 --
 -- These functions operate on whole PArrays.
index b10855a..ad0ce18 100644 (file)
@@ -17,7 +17,6 @@ module Data.Array.Parallel.Lifted.Repr (
 ) where
 
 import Data.Array.Parallel.Lifted.TH.Repr
-
 import Data.Array.Parallel.Lifted.PArray
 import Data.Array.Parallel.Lifted.Unboxed ( elementsSegd#, elementsSel2_0#,
                                             elementsSel2_1# )
index 75d9955..6f0fdb5 100644 (file)
@@ -3,11 +3,10 @@
 --   and the operators we can apply to it.
 --
 module Data.Array.Parallel.PArray.PData (
-  -- * Type family of Parallel Data.
   PData,
-
-  -- * Types of primitive operators on Parallel Data.
   PR(..),
+
+  -- These types have corresponding members in the PR class.
   T_emptyPR,
   T_replicatePR,
   T_replicatelPR,
@@ -29,6 +28,7 @@ import Data.Array.Parallel.Base                 (Tag)
 import GHC.Exts                                 (Int#)
 import SpecConstr
 
+
 -- | Parallel Data.
 --   This is the family of types that store parallel array data.
 --
@@ -66,6 +66,7 @@ class PR a where
   nfPR         :: T_nfPR a
 
 
+-- Operator Types -------------------------------------------------------------
 -- | An empty array.
 type T_emptyPR      a 
         =  PData a
diff --git a/dph-common/Data/Array/Parallel/PArray/PRepr.hs b/dph-common/Data/Array/Parallel/PArray/PRepr.hs
new file mode 100644 (file)
index 0000000..5ca1d3a
--- /dev/null
@@ -0,0 +1,149 @@
+{-# 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.
+--
+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
+
+
+-- 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)
+
+
index ec61ae0..f115219 100644 (file)
@@ -29,8 +29,8 @@ class U.Elt a => Scalar a where
 
 
 -- Scalar Wrappers ------------------------------------------------------------
---  These operators work on (PData a) arrays when we know the element 'a' type is
---  scalar. For most of them we can just coerce the PData to the underling 
+--  These wrappers work on (PData a) arrays when we know the element type 'a'
+--  is scalar. For most of them we can just coerce the PData to the underling 
 --  U.Array and use the corresponding U.Array operator.
 --
 --  The underlying U.Array may be processed in parallel or sequentially,
index 8352c5f..f7fef0b 100644 (file)
@@ -28,8 +28,9 @@ Library
         Data.Array.Parallel.PArray
 
   Other-Modules:
-        Data.Array.Parallel.PArray.PData
         Data.Array.Parallel.PArray.Scalar
+        Data.Array.Parallel.PArray.PRepr
+        Data.Array.Parallel.PArray.PData
         Data.Array.Parallel.Lifted.PArray
         Data.Array.Parallel.Lifted.Unboxed
         Data.Array.Parallel.Lifted.Scalar