Merge Prim with Scalar
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 9 Nov 2009 13:17:05 +0000 (13:17 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Mon, 9 Nov 2009 13:17:05 +0000 (13:17 +0000)
dph-common/Data/Array/Parallel/Lifted/PArray.hs
dph-common/Data/Array/Parallel/Lifted/Repr.hs
dph-common/Data/Array/Parallel/Lifted/Scalar.hs
dph-common/Data/Array/Parallel/Lifted/TH/Repr.hs

index 200d1ac..674ab08 100644 (file)
@@ -16,11 +16,11 @@ module Data.Array.Parallel.Lifted.PArray (
 
   PRepr, PR(..),
 
-  Prim(..),
-  replicatePRPrim, replicatelPRPrim, repeatPRPrim, repeatcPRPrim, emptyPRPrim,
-  indexPRPrim, extractPRPrim, bpermutePRPrim, appPRPrim, applPRPrim,
-  packPRPrim, packByTagPRPrim, combine2PRPrim, fromListPRPrim, fromListPRPrim,
-  nfPRPrim,
+  Scalar(..),
+  replicatePRScalar, replicatelPRScalar, repeatPRScalar, repeatcPRScalar, emptyPRScalar,
+  indexPRScalar, extractPRScalar, bpermutePRScalar, appPRScalar, applPRScalar,
+  packPRScalar, packByTagPRScalar, combine2PRScalar, fromListPRScalar, fromListPRScalar,
+  nfPRScalar,
 ) where
 
 import qualified Data.Array.Parallel.Unlifted as U
@@ -270,83 +270,83 @@ nfPA :: PA a => PArray a -> ()
 nfPA (PArray _ xs) = nfPD xs
 
 
-class U.Elt a => Prim a where
-  fromPrimPData :: PData a -> U.Array a
-  toPrimPData   :: U.Array a -> PData a
+class U.Elt a => Scalar a where
+  fromScalarPData :: PData a -> U.Array a
+  toScalarPData   :: U.Array a -> PData a
 
-emptyPRPrim :: Prim a => T_emptyPR a
-{-# INLINE emptyPRPrim #-}
-emptyPRPrim = toPrimPData U.empty
+emptyPRScalar :: Scalar a => T_emptyPR a
+{-# INLINE emptyPRScalar #-}
+emptyPRScalar = toScalarPData U.empty
 
-replicatePRPrim :: Prim a => T_replicatePR a
-{-# INLINE replicatePRPrim #-}
-replicatePRPrim n# x = toPrimPData (U.replicate (I# n#) x)
+replicatePRScalar :: Scalar a => T_replicatePR a
+{-# INLINE replicatePRScalar #-}
+replicatePRScalar n# x = toScalarPData (U.replicate (I# n#) x)
 
-replicatelPRPrim :: Prim a => T_replicatelPR a
-{-# INLINE replicatelPRPrim #-}
-replicatelPRPrim segd xs = toPrimPData
+replicatelPRScalar :: Scalar a => T_replicatelPR a
+{-# INLINE replicatelPRScalar #-}
+replicatelPRScalar segd xs = toScalarPData
                          $ U.replicate_s segd 
-                         $ fromPrimPData xs
+                         $ fromScalarPData xs
 
-repeatPRPrim :: Prim a => T_repeatPR a
-{-# INLINE repeatPRPrim #-}
-repeatPRPrim n# len# xs = toPrimPData
+repeatPRScalar :: Scalar a => T_repeatPR a
+{-# INLINE repeatPRScalar #-}
+repeatPRScalar n# len# xs = toScalarPData
                         $ U.repeat (I# n#) (I# len#)
-                        $ fromPrimPData xs
+                        $ fromScalarPData xs
 
-repeatcPRPrim :: Prim a => T_repeatcPR a
-{-# INLINE repeatcPRPrim #-}
-repeatcPRPrim n# ns segd xs = toPrimPData
+repeatcPRScalar :: Scalar a => T_repeatcPR a
+{-# INLINE repeatcPRScalar #-}
+repeatcPRScalar n# ns segd xs = toScalarPData
                             $ U.repeat_c (I# n#) ns segd
-                            $ fromPrimPData xs
-
-indexPRPrim :: Prim a => T_indexPR a
-{-# INLINE indexPRPrim #-}
-indexPRPrim xs i# = fromPrimPData xs U.!: I# i#
-
-extractPRPrim :: Prim a => T_extractPR a
-{-# INLINE extractPRPrim #-}
-extractPRPrim xs i# n# = toPrimPData
-                       $ U.extract (fromPrimPData xs) (I# i#) (I# n#)
-
-bpermutePRPrim :: Prim a => T_bpermutePR a
-{-# INLINE bpermutePRPrim #-}
-bpermutePRPrim xs _ is = toPrimPData
-                       $ U.bpermute (fromPrimPData xs) is
-
-appPRPrim :: Prim a => T_appPR a
-{-# INLINE appPRPrim #-}
-appPRPrim xs ys = toPrimPData
-                $ fromPrimPData xs U.+:+ fromPrimPData ys
-
-applPRPrim :: Prim a => T_applPR a
-{-# INLINE applPRPrim #-}
-applPRPrim xsegd xs ysegd ys = toPrimPData
-                             $ U.append_s xsegd (fromPrimPData xs)
-                                          ysegd (fromPrimPData ys)
+                            $ fromScalarPData xs
+
+indexPRScalar :: Scalar a => T_indexPR a
+{-# INLINE indexPRScalar #-}
+indexPRScalar xs i# = fromScalarPData xs U.!: I# i#
+
+extractPRScalar :: Scalar a => T_extractPR a
+{-# INLINE extractPRScalar #-}
+extractPRScalar xs i# n# = toScalarPData
+                       $ U.extract (fromScalarPData xs) (I# i#) (I# n#)
+
+bpermutePRScalar :: Scalar a => T_bpermutePR a
+{-# INLINE bpermutePRScalar #-}
+bpermutePRScalar xs _ is = toScalarPData
+                       $ U.bpermute (fromScalarPData xs) is
+
+appPRScalar :: Scalar a => T_appPR a
+{-# INLINE appPRScalar #-}
+appPRScalar xs ys = toScalarPData
+                $ fromScalarPData xs U.+:+ fromScalarPData ys
+
+applPRScalar :: Scalar a => T_applPR a
+{-# INLINE applPRScalar #-}
+applPRScalar xsegd xs ysegd ys = toScalarPData
+                             $ U.append_s xsegd (fromScalarPData xs)
+                                          ysegd (fromScalarPData ys)
                         
-packPRPrim :: Prim a => T_packPR a
-{-# INLINE packPRPrim #-}
-packPRPrim xs _ bs = toPrimPData
-                   $ U.pack (fromPrimPData xs) bs
-
-packByTagPRPrim :: Prim a => T_packByTagPR a
-{-# INLINE packByTagPRPrim #-}
-packByTagPRPrim xs _ tags t# = toPrimPData
-                             $ U.packByTag (fromPrimPData xs) tags (I# t#)
-
-combine2PRPrim :: Prim a => T_combine2PR a
-{-# INLINE combine2PRPrim #-}
-combine2PRPrim _ sel xs ys = toPrimPData
+packPRScalar :: Scalar a => T_packPR a
+{-# INLINE packPRScalar #-}
+packPRScalar xs _ bs = toScalarPData
+                   $ U.pack (fromScalarPData xs) bs
+
+packByTagPRScalar :: Scalar a => T_packByTagPR a
+{-# INLINE packByTagPRScalar #-}
+packByTagPRScalar xs _ tags t# = toScalarPData
+                             $ U.packByTag (fromScalarPData xs) tags (I# t#)
+
+combine2PRScalar :: Scalar a => T_combine2PR a
+{-# INLINE combine2PRScalar #-}
+combine2PRScalar _ sel xs ys = toScalarPData
                            $ U.combine (U.pick (tagsSel2 sel) 0)
-                                       (fromPrimPData xs)
-                                       (fromPrimPData ys)
+                                       (fromScalarPData xs)
+                                       (fromScalarPData ys)
 
-fromListPRPrim :: Prim a => T_fromListPR a
-{-# INLINE fromListPRPrim #-}
-fromListPRPrim _ xs = toPrimPData (U.fromList xs)
+fromListPRScalar :: Scalar a => T_fromListPR a
+{-# INLINE fromListPRScalar #-}
+fromListPRScalar _ xs = toScalarPData (U.fromList xs)
 
-nfPRPrim :: Prim a => T_nfPR a
-{-# INLINE nfPRPrim #-}
-nfPRPrim xs = fromPrimPData xs `seq` ()
+nfPRScalar :: Scalar a => T_nfPR a
+{-# INLINE nfPRScalar #-}
+nfPRScalar xs = fromScalarPData xs `seq` ()
 
index 20db73c..4c54528 100644 (file)
@@ -31,21 +31,21 @@ import GHC.Exts  (Int#, Int(..), (+#), (-#), (*#))
 import GHC.Word  ( Word8 )
 
 
----------------------
--- Primitive types --
+------------------
+-- Scalar types --
 
 -- Generate
 --
 -- newtype instance PData Int = PInt (U.Array Int)
 --
--- instance Prim Int where
---   fromPrimPData (PInt xs) = xs
---   toPrimPData = PInt
+-- instance Scalar Int where
+--   fromScalarPData (PInt xs) = xs
+--   toScalarPData = PInt
 --
 -- instance PR Int where
---   <forward to *PRPrim methods>
+--   <forward to *PRScalar methods>
 
-$(primInstances [''Int, ''Double, ''Word8])
+$(scalarInstances [''Int, ''Double, ''Word8])
 
 ----------
 -- Void --
index 474b10e..fafe0d2 100644 (file)
@@ -19,17 +19,13 @@ import Data.Array.Parallel.Base ((:*:)(..), fstS, pairS, unpairS,
 import GHC.Exts ( Int(..), (-#) )
 import GHC.Word ( Word8 )
 
-class (U.Elt a, PA a)  => Scalar a where
-  fromUArrPD :: U.Array a -> PData a
-  toUArrPD   :: PData a -> U.Array a
-
 fromUArrPA :: Scalar a => Int -> U.Array a -> PArray a
 {-# INLINE fromUArrPA #-}
-fromUArrPA (I# n#) xs = PArray n# (fromUArrPD xs)
+fromUArrPA (I# n#) xs = PArray n# (toScalarPData xs)
 
 toUArrPA :: Scalar a => PArray a -> U.Array a
 {-# INLINE toUArrPA #-}
-toUArrPA (PArray _ xs) = toUArrPD xs
+toUArrPA (PArray _ xs) = fromScalarPData xs
 
 prim_lengthPA :: Scalar a => PArray a -> Int
 {-# INLINE prim_lengthPA #-}
@@ -108,29 +104,19 @@ scalar_fold1sIndex f xss = fromUArrPA n
 
     segd = segdPA# xss
 
-instance Scalar Int where
-  fromUArrPD xs        = PInt xs
-  toUArrPD   (PInt xs) = xs
-
-instance Scalar Word8 where
-  fromUArrPD  xs         = PWord8 xs
-  toUArrPD   (PWord8 xs) = xs
-
-instance Scalar Double where
-  fromUArrPD  xs          = PDouble xs
-  toUArrPD   (PDouble xs) = xs
-
+-- FIXME: hack!
+--
 instance Scalar Bool where
-  {-# INLINE fromUArrPD #-}
-  fromUArrPD bs
+  {-# INLINE toScalarPData #-}
+  toScalarPData bs
     = PBool (tagsToSel2 (U.map fromBool bs))
 
-  {-# INLINE toUArrPD #-}
-  toUArrPD (PBool sel) = U.map toBool (tagsSel2 sel)
+  {-# INLINE fromScalarPData #-}
+  fromScalarPData (PBool sel) = U.map toBool (tagsSel2 sel)
 
 fromUArrPA_2 :: (Scalar a, Scalar b) => Int -> U.Array (a :*: b) -> PArray (a,b)
 {-# INLINE fromUArrPA_2 #-}
-fromUArrPA_2 (I# n#) ps = PArray n# (P_2 (fromUArrPD xs) (fromUArrPD  ys))
+fromUArrPA_2 (I# n#) ps = PArray n# (P_2 (toScalarPData xs) (toScalarPData  ys))
   where
     xs :*: ys = U.unzip ps
 
@@ -141,9 +127,9 @@ fromUArrPA_2' ps = fromUArrPA_2 (U.length ps) ps
 fromUArrPA_3 :: (Scalar a, Scalar b, Scalar c)
              => Int -> U.Array (a :*: b :*: c) -> PArray (a,b,c)
 {-# INLINE fromUArrPA_3 #-}
-fromUArrPA_3 (I# n#) ps = PArray n# (P_3 (fromUArrPD xs)
-                                         (fromUArrPD ys)
-                                         (fromUArrPD zs))
+fromUArrPA_3 (I# n#) ps = PArray n# (P_3 (toScalarPData xs)
+                                         (toScalarPData ys)
+                                         (toScalarPData zs))
   where
     xs :*: ys :*: zs = U.unzip3 ps
 
index 3fd4376..1ccf735 100644 (file)
@@ -1,6 +1,7 @@
 {-# LANGUAGE TemplateHaskell, Rank2Types #-}
 module Data.Array.Parallel.Lifted.TH.Repr (
-  primInstances, tupleInstances, voidPRInstance, unitPRInstance, wrapPRInstance
+  scalarInstances, tupleInstances,
+  voidPRInstance, unitPRInstance, wrapPRInstance
 ) where
 
 import qualified Data.Array.Parallel.Unlifted as U
@@ -187,55 +188,55 @@ nameGens =
   ]
 
 -- ---------------
--- Primitive types
+-- Scalar types
 -- ---------------
 
-primInstances :: [Name] -> Q [Dec]
-primInstances tys
+scalarInstances :: [Name] -> Q [Dec]
+scalarInstances tys
   = do
-      pdatas <- mapM instance_PData_prim tys
-      prims  <- mapM instance_Prim_prim tys
-      prs    <- mapM instance_PR_prim tys
-      return $ pdatas ++ prims ++ prs
+      pdatas <- mapM instance_PData_scalar tys
+      scalars  <- mapM instance_Scalar_scalar tys
+      prs    <- mapM instance_PR_scalar tys
+      return $ pdatas ++ scalars ++ prs
 
-pdataPrimCon :: Name -> Name
-pdataPrimCon n = mkName ("P" ++ nameBase n)
+pdataScalarCon :: Name -> Name
+pdataScalarCon n = mkName ("P" ++ nameBase n)
 
-instance_PData_prim :: Name -> DecQ
-instance_PData_prim tycon
-  = newtype_instance_PData tycon [] (pdataPrimCon tycon)
+instance_PData_scalar :: Name -> DecQ
+instance_PData_scalar tycon
+  = newtype_instance_PData tycon [] (pdataScalarCon tycon)
                                     (conT ''U.Array `appT` conT tycon)
 
-instance_Prim_prim :: Name -> DecQ
-instance_Prim_prim ty
+instance_Scalar_scalar :: Name -> DecQ
+instance_Scalar_scalar ty
   = instanceD (cxt [])
-              (conT ''Prim `appT` conT ty)
+              (conT ''Scalar `appT` conT ty)
               (map (inlineD . mkName . fst) methods ++ map snd methods)
   where
-    pcon = pdataPrimCon ty
+    pcon = pdataScalarCon ty
     xs   = mkName "xs"
 
-    methods = [("fromPrimPData", mk_fromPrimPData),
-               ("toPrimPData",   mk_toPrimPData)]
+    methods = [("fromScalarPData", mk_fromScalarPData),
+               ("toScalarPData",   mk_toScalarPData)]
 
-    mk_fromPrimPData = simpleFunD (mkName "fromPrimPData")
+    mk_fromScalarPData = simpleFunD (mkName "fromScalarPData")
                                   [conP pcon [varP xs]]
                                   (varE xs)
-    mk_toPrimPData = simpleFunD (mkName "toPrimPData") [] (conE pcon)
+    mk_toScalarPData = simpleFunD (mkName "toScalarPData") [] (conE pcon)
 
-instance_PR_prim :: Name -> DecQ
-instance_PR_prim ty
+instance_PR_scalar :: Name -> DecQ
+instance_PR_scalar ty
   = do
-      methods <- genPR_methods (primitiveMethod ty)
+      methods <- genPR_methods (scalarMethod ty)
       return $ InstanceD []
                          (ConT ''PR `AppT` ConT ty)
                          methods
 
-primitiveMethod :: Name -> Name -> [ArgVal] -> Val -> DecQ
-primitiveMethod ty meth avs res
+scalarMethod :: Name -> Name -> [ArgVal] -> Val -> DecQ
+scalarMethod ty meth avs res
   = simpleFunD (mkName $ nameBase meth) []
   $ varE
-  $ mkName (nameBase meth ++ "Prim")
+  $ mkName (nameBase meth ++ "Scalar")
 
 {-
   = simpleFunD (mkName $ nameBase meth) pats