Make the type of tags configurable and use Word8 instead of Int for now
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 10 Jun 2010 06:23:56 +0000 (06:23 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 10 Jun 2010 06:23:56 +0000 (06:23 +0000)
12 files changed:
dph-base/Data/Array/Parallel/Base/Util.hs
dph-base/Data/Array/Parallel/Stream/Flat/Combinators.hs
dph-common/Data/Array/Parallel/Lifted/Combinators.hs
dph-common/Data/Array/Parallel/Lifted/PArray.hs
dph-common/Data/Array/Parallel/Lifted/Repr.hs
dph-common/Data/Array/Parallel/Lifted/Unboxed.hs
dph-prim-interface/Data/Array/Parallel/Unlifted.hs
dph-prim-interface/interface/DPH_Interface.h
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Combinators.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSel.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Flat/Combinators.hs
dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Flat/USel.hs

index 7baa730..f9bdc70 100644 (file)
@@ -1,14 +1,26 @@
 module Data.Array.Parallel.Base.Util (
-  fromBool, toBool
+  Tag, fromBool, toBool, tagToInt, intToTag
 ) where
 
-fromBool :: Bool -> Int
+import Data.Word ( Word8 )
+
+type Tag = Word8
+
+fromBool :: Bool -> Tag
 fromBool False = 0
 fromBool True  = 1
 {-# INLINE fromBool #-}
 
-toBool :: Int -> Bool
+toBool :: Tag -> Bool
 toBool n | n == 0    = False
          | otherwise = True
 {-# INLINE toBool #-}
 
+tagToInt :: Tag -> Int
+tagToInt = fromEnum
+{-# INLINE tagToInt #-}
+
+intToTag :: Int -> Tag
+intToTag = toEnum
+{-# INLINE intToTag #-}
+
index aa8807b..f2aeb65 100644 (file)
@@ -22,7 +22,7 @@ module Data.Array.Parallel.Stream.Flat.Combinators (
 ) where
 
 import Data.Array.Parallel.Base (
-  (:*:)(..), MaybeS(..), Rebox(..) )
+  (:*:)(..), MaybeS(..), Rebox(..), Tag )
 import Data.Array.Parallel.Base.DTrace
 import Data.Array.Parallel.Stream.Flat.Stream
 
@@ -152,7 +152,7 @@ combineS (Stream next1 s m c) (Stream nextS1 t1 n1 c1) (Stream nextS2 t2 n2 c2)
                                Yield x t2' -> Yield x (s' :*: t1 :*: t2')
 
 
-combine2ByTagS :: Stream Int -> Stream a -> Stream a -> Stream a
+combine2ByTagS :: Stream Tag -> Stream a -> Stream a -> Stream a
 {-# INLINE_STREAM combine2ByTagS #-}
 combine2ByTagS (Stream next_tag s m c) (Stream next0 s0 _ c1)
                                        (Stream next1 s1 _ c2)
index 5512dd2..75b3905 100644 (file)
@@ -24,7 +24,7 @@ import Data.Array.Parallel.Lifted.Instances
 import Data.Array.Parallel.Lifted.Scalar
 
 import qualified Data.Array.Parallel.Unlifted as U
-import Data.Array.Parallel.Base ( fromBool )
+import Data.Array.Parallel.Base ( Tag, fromBool )
 
 import GHC.Exts (Int(..), (+#), (-#), Int#, (<#))
 
@@ -233,7 +233,7 @@ packPA = closure2 packPA_v packPA_l
 
 -- combine --------------------------------------------------------------------
 -- TODO: should the selector be a boolean array?
-combine2PA_v:: PA a => PArray a -> PArray a -> PArray Int -> PArray a
+combine2PA_v:: PA a => PArray a -> PArray a -> PArray Tag -> PArray a
 {-# INLINE_PA combine2PA_v #-}
 combine2PA_v xs ys bs
   = combine2PA# (lengthPA# xs +# lengthPA# ys)
@@ -241,13 +241,13 @@ combine2PA_v xs ys bs
                 xs ys
 
 combine2PA_l:: PA a
-            => PArray (PArray a) -> PArray (PArray a) -> PArray (PArray Int)
+            => PArray (PArray a) -> PArray (PArray a) -> PArray (PArray Tag)
                -> PArray (PArray a)
 {-# INLINE_PA combine2PA_l #-}
 combine2PA_l _ _ _ = error "combinePA_l nyi"
     
 
-combine2PA:: PA a => PArray a :-> PArray a :-> PArray Int :-> PArray a
+combine2PA:: PA a => PArray a :-> PArray a :-> PArray Tag :-> PArray a
 {-# INLINE_PA combine2PA #-}
 combine2PA = closure3 combine2PA_v combine2PA_l
 
index 6beb537..c273672 100644 (file)
@@ -33,7 +33,7 @@ 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 ( traceF )
+import Data.Array.Parallel.Base ( Tag, intToTag, traceF )
 import GHC.Exts (Int#, Int(..), (+#), (*#))
 import SpecConstr
 
@@ -167,7 +167,7 @@ type T_applPR       a =  U.Segd              -- result segd
 --
 type T_packByTagPR  a = PData a            -- source array
                       -> Int#              -- length of resulting array
-                      -> U.Array Int       -- tag values of elements in source array
+                      -> U.Array Tag       -- tag values of elements in source array
                       -> Int#              -- tag value of the elements to select
                       -> PData a
 
@@ -327,7 +327,7 @@ applPA# :: PA a => U.Segd -> U.Segd -> PArray a -> U.Segd -> PArray a -> PArray
 applPA# segd is (PArray m# xs) js (PArray n# ys)
   = PArray (m# +# n#) (applPD segd is xs js ys)
 
-packByTagPA# :: PA a => PArray a -> Int# -> U.Array Int -> Int# -> PArray a
+packByTagPA# :: PA a => PArray a -> Int# -> U.Array Tag -> Int# -> PArray a
 {-# INLINE_PA packByTagPA# #-}
 packByTagPA# (PArray _ xs) n# tags t# = PArray n# (packByTagPD xs n# tags t#)
 
@@ -427,7 +427,9 @@ packByTagPRScalar :: Scalar a => T_packByTagPR a
 {-# INLINE packByTagPRScalar #-}
 packByTagPRScalar xs _ tags t# = traceF "packByTagPRScalar"
                              $ toScalarPData
-                             $ U.packByTag (fromScalarPData xs) tags (I# t#)
+                             $ U.packByTag (fromScalarPData xs)
+                                           tags
+                                           (intToTag (I# t#))
 
 combine2PRScalar :: Scalar a => T_combine2PR a
 {-# INLINE combine2PRScalar #-}
index 1f8bc65..4be95cd 100644 (file)
@@ -23,7 +23,7 @@ import Data.Array.Parallel.Lifted.Unboxed ( elementsSegd#, elementsSel2_0#,
                                             elementsSel2_1# )
 
 import qualified Data.Array.Parallel.Unlifted as U
-import Data.Array.Parallel.Base ((:*:)(..), fromBool)
+import Data.Array.Parallel.Base ((:*:)(..), intToTag, fromBool)
 import Data.Array.Parallel.Base.DTrace ( traceFn, traceArg )
 
 import Data.List (unzip4, unzip5)
@@ -260,7 +260,7 @@ instance (PR a, PR b) => PR (Sum2 a b) where
     = PSum2 sel' as' bs'
     where
       my_tags  = U.tagsSel2 sel
-      my_tags' = U.packByTag my_tags tags (I# t#)
+      my_tags' = U.packByTag my_tags tags (intToTag (I# t#))
       sel'     = U.tagsToSel2 my_tags'
 
       atags    = U.packByTag tags my_tags 0
@@ -378,7 +378,7 @@ instance PR a => PR (PArray a) where
       PNested segd' xs'
     where
       segd' = U.lengthsToSegd
-            $ U.packByTag (U.lengthsSegd segd) tags (I# t#)
+            $ U.packByTag (U.lengthsSegd segd) tags (intToTag (I# t#))
 
       xs'   = packByTagPR xs (elementsSegd# segd') (U.replicate_s segd tags) t#
 
index 4e49936..a446dcc 100644 (file)
@@ -50,7 +50,8 @@ module Data.Array.Parallel.Lifted.Unboxed (
 ) where
 
 import qualified Data.Array.Parallel.Unlifted as U
-import Data.Array.Parallel.Base ((:*:)(..), fromBool, toBool)
+import Data.Array.Parallel.Base (
+  (:*:)(..), Tag, fromBool, toBool, intToTag, tagToInt )
 
 import GHC.Exts ( Int#, Int(..), Word#,
                   Double#, Double(..) )
@@ -88,20 +89,20 @@ mkSegd# ns is n# = U.mkSegd ns is (I# n#)
 
 replicateSel2# :: Int# -> Int# -> Sel2
 {-# INLINE replicateSel2# #-}
-replicateSel2# n# tag# = U.mkSel2 (U.replicate n tag)
+replicateSel2# n# tag# = U.mkSel2 (U.replicate n (intToTag tag))
                                   (U.enumFromStepLen 0 1 n)
                                   (if tag == 0 then n else 0)
                                   (if tag == 0 then 0 else n)
-                                  (U.mkSelRep2 (U.replicate n tag))
+                                  (U.mkSelRep2 (U.replicate n (intToTag tag)))
   where
     n = I# n#
     tag = I# tag#
 
 pickSel2# :: Sel2 -> Int# -> U.Array Bool
 {-# INLINE pickSel2# #-}
-pickSel2# sel tag# = U.pick (U.tagsSel2 sel) (I# tag#)
+pickSel2# sel tag# = U.pick (U.tagsSel2 sel) (intToTag (I# tag#))
 
-tagsSel2 :: Sel2 -> U.Array Int
+tagsSel2 :: Sel2 -> U.Array Tag
 {-# INLINE tagsSel2 #-}
 tagsSel2 = U.tagsSel2
 
@@ -451,10 +452,10 @@ truesPAs_Bool# segd = sumPAs_Int# segd . fromBoolPA#
 {-# INLINE truesPAs_Bool# #-}
 
 fromBoolPA# :: PArray_Bool# -> PArray_Int#
-fromBoolPA# = U.map fromBool
+fromBoolPA# = U.map (tagToInt . fromBool)
 {-# INLINE_PA fromBoolPA# #-}
 
 toBoolPA# :: PArray_Int# -> PArray_Bool#
-toBoolPA# = U.map toBool
+toBoolPA# = U.map (toBool . intToTag)
 {-# INLINE_PA toBoolPA# #-}
 
index 51a5916..d8a69f2 100644 (file)
@@ -25,7 +25,7 @@ data Segd = Segd { segd_lengths  :: [Int]
                  , segd_elements :: Int
                  }
 
-data Sel2 = Sel2 { sel2_tags      :: [Int]
+data Sel2 = Sel2 { sel2_tags      :: [Tag]
                  , sel2_indices   :: [Int]
                  , sel2_elements0 :: Int
                  , sel2_elements1 :: Int
@@ -33,6 +33,7 @@ data Sel2 = Sel2 { sel2_tags      :: [Int]
 
 type SelRep2 = ()
 
+
 length = P.length
 empty = []
 replicate = P.replicate
index a4a4e1d..13799f0 100644 (file)
@@ -1,4 +1,4 @@
-import Data.Array.Parallel.Base ( fromBool )
+import Data.Array.Parallel.Base ( Tag, tagToInt, fromBool )
 import qualified GHC.Base
 import Prelude ((.), ($), Num(..), Eq(..), seq)
 
@@ -65,7 +65,7 @@ pack :: Elt a => Array a -> Array Bool -> Array a
 combine :: Elt a => Array Bool -> Array a -> Array a -> Array a
 {-# INLINE_BACKEND combine #-}
 
-combine2 :: Elt a => Array Int -> SelRep2 -> Array a -> Array a -> Array a
+combine2 :: Elt a => Array Tag -> SelRep2 -> Array a -> Array a -> Array a
 {-# INLINE_BACKEND combine2 #-}
 
 map :: (Elt a, Elt b) => (a -> b) -> Array a -> Array b
@@ -265,10 +265,10 @@ plusSegd segd1 segd2
 
  #-}
 
-mkSel2 :: Array Int -> Array Int -> Int -> Int -> SelRep2 -> Sel2
+mkSel2 :: Array Tag -> Array Int -> Int -> Int -> SelRep2 -> Sel2
 {-# INLINE CONLIKE PHASE_BACKEND mkSel2 #-}
 
-tagsSel2 :: Sel2 -> Array Int
+tagsSel2 :: Sel2 -> Array Tag
 {-# INLINE_BACKEND tagsSel2 #-}
 
 indicesSel2 :: Sel2 -> Array Int
@@ -283,19 +283,19 @@ elementsSel2_1 :: Sel2 -> Int
 repSel2 :: Sel2 -> SelRep2
 {-# INLINE_BACKEND repSel2 #-}
 
-mkSelRep2 :: Array Int -> SelRep2
+mkSelRep2 :: Array Tag -> SelRep2
 {-# INLINE CONLIKE PHASE_BACKEND mkSelRep2 #-}
 
-indicesSelRep2 :: Array Int -> SelRep2 -> Array Int
+indicesSelRep2 :: Array Tag -> SelRep2 -> Array Int
 {-# INLINE_BACKEND indicesSelRep2 #-}
 
-elementsSelRep2_0 :: Array Int -> SelRep2 -> Int
+elementsSelRep2_0 :: Array Tag -> SelRep2 -> Int
 {-# INLINE_BACKEND elementsSelRep2_0 #-}
 
-elementsSelRep2_1 :: Array Int -> SelRep2 -> Int
+elementsSelRep2_1 :: Array Tag -> SelRep2 -> Int
 {-# INLINE_BACKEND elementsSelRep2_1 #-}
 
-tagsToSel2 :: Array Int -> Sel2
+tagsToSel2 :: Array Tag -> Sel2
 {-# INLINE tagsToSel2 #-}
 tagsToSel2 tags = let rep = mkSelRep2 tags
                   in
@@ -320,7 +320,7 @@ tagsToSel2 tags = let rep = mkSelRep2 tags
   #-}
 
 
-packByTag :: Elt a => Array a -> Array Int -> Int -> Array a
+packByTag :: Elt a => Array a -> Array Tag -> Tag -> Array a
 {-# INLINE_BACKEND packByTag #-}
 packByTag xs tags !tag = fsts (filter (\p -> sndS p == tag) (zip xs tags))
 
@@ -348,7 +348,7 @@ pick xs !x = map (x==) xs
 
 count :: (Elt a, Eq a) => Array a -> a -> Int
 {-# INLINE_BACKEND count #-}
-count xs !x = sum (map (fromBool . (==) x) xs)
+count xs !x = sum (map (tagToInt . fromBool . (==) x) xs)
 
 {-# RULES
 
@@ -358,7 +358,7 @@ count xs !x = sum (map (fromBool . (==) x) xs)
 
 count_s :: (Elt a, Eq a) => Segd -> Array a -> a -> Array Int
 {-# INLINE_BACKEND count_s #-}
-count_s segd xs !x = sum_s segd (map (fromBool . (==) x) xs)
+count_s segd xs !x = sum_s segd (map (tagToInt . fromBool . (==) x) xs)
 
 randoms :: (Elt a, System.Random.Random a, System.Random.RandomGen g)
         => Int -> g -> Array a
@@ -469,7 +469,7 @@ dph_mult x y = x Prelude.* y
 
 -- Quickhull rules
 
-tagZeroes :: Array Int -> Array Int
+tagZeroes :: Array Int -> Array Tag
 {-# INLINE CONLIKE PHASE_BACKEND tagZeroes #-}
 tagZeroes xs = map (\x -> fromBool (x==0)) xs
 
index 9053175..cd9303d 100644 (file)
@@ -69,7 +69,7 @@ combineUP flags !xs !ys = joinD theGang balanced
     go ((i,j), (m,n)) bs = combineU bs (sliceU xs i m) (sliceU ys j n)
 -}
 
-combine2UP :: UA a => UArr Int -> UPSelRep2 -> UArr a -> UArr a -> UArr a
+combine2UP :: UA a => UArr Tag -> UPSelRep2 -> UArr a -> UArr a -> UArr a
 {-# INLINE_UP combine2UP #-}
 combine2UP tags rep !xs !ys = joinD theGang balanced
                             $ zipWithD theGang go rep
index fcf0513..61aff7b 100644 (file)
@@ -30,7 +30,7 @@ module Data.Array.Parallel.Unlifted.Parallel.UPSel (
 
 import Data.Array.Parallel.Unlifted.Sequential
 import Data.Array.Parallel.Unlifted.Distributed
-import Data.Array.Parallel.Base ((:*:)(..), fstS)
+import Data.Array.Parallel.Base (Tag, tagToInt, (:*:)(..), fstS)
 
   -- (offset as :*: offset bs) :*: (length as :*: length bs)
 type UPSelRep2 = Dist ((Int,Int), (Int,Int))
@@ -38,7 +38,7 @@ data UPSel2 = UPSel2 { upsel2_usel :: USel2
                      , upsel2_rep  :: UPSelRep2
                      }
 
-tagsUPSel2 :: UPSel2 -> UArr Int
+tagsUPSel2 :: UPSel2 -> UArr Tag
 {-# INLINE tagsUPSel2 #-}
 tagsUPSel2 = tagsUSel2 .  upsel2_usel
 
@@ -62,7 +62,7 @@ repUPSel2 :: UPSel2 -> UPSelRep2
 {-# INLINE repUPSel2 #-}
 repUPSel2 = upsel2_rep
 
-mkUPSelRep2 :: UArr Int -> UPSelRep2
+mkUPSelRep2 :: UArr Tag -> UPSelRep2
 {-# INLINE mkUPSelRep2 #-}
 mkUPSelRep2 tags = zipD idxs lens
   where
@@ -72,12 +72,12 @@ mkUPSelRep2 tags = zipD idxs lens
     idxs = fstS
          $ scanD theGang add (0,0) lens
 
-    count bs = let ones = sumU bs
+    count bs = let ones = sumU (mapU tagToInt bs)
                in (lengthU bs - ones,ones)
 
     add (x1,y1) (x2,y2) = (x1+x2, y1+y2)
 
-indicesUPSelRep2 :: UArr Int -> UPSelRep2 -> UArr Int
+indicesUPSelRep2 :: UArr Tag -> UPSelRep2 -> UArr Int
 {-# INLINE indicesUPSelRep2 #-}
 indicesUPSelRep2 tags rep = joinD theGang balanced
                           $ zipWithD theGang indices
@@ -88,15 +88,15 @@ indicesUPSelRep2 tags rep = joinD theGang balanced
       = combine2ByTagU tags (enumFromStepLenU i 1 m)
                             (enumFromStepLenU j 1 n)
 
-elementsUPSelRep2_0 :: UArr Int -> UPSelRep2 -> Int
+elementsUPSelRep2_0 :: UArr Tag -> UPSelRep2 -> Int
 {-# INLINE elementsUPSelRep2_0 #-}
 elementsUPSelRep2_0 _ = sumD theGang . fstD . sndD
 
-elementsUPSelRep2_1 :: UArr Int -> UPSelRep2 -> Int
+elementsUPSelRep2_1 :: UArr Tag -> UPSelRep2 -> Int
 {-# INLINE elementsUPSelRep2_1 #-}
 elementsUPSelRep2_1 _ = sumD theGang . sndD . sndD
 
-mkUPSel2 :: UArr Int -> UArr Int -> Int -> Int -> UPSelRep2 -> UPSel2
+mkUPSel2 :: UArr Tag -> UArr Int -> Int -> Int -> UPSelRep2 -> UPSel2
 {-# INLINE mkUPSel2 #-}
 mkUPSel2 tags is n0 n1 rep = UPSel2 (mkUSel2 tags is n0 n1) rep
 
index db997f1..15ee0b5 100644 (file)
@@ -35,7 +35,7 @@ module Data.Array.Parallel.Unlifted.Sequential.Flat.Combinators (
 ) where
 
 import Data.Array.Parallel.Base (
-  (:*:)(..), MaybeS(..), checkNotEmpty, checkEq, sndS, Rebox(..), ST, runST)
+  Tag, (:*:)(..), MaybeS(..), checkNotEmpty, checkEq, sndS, Rebox(..), ST, runST)
 import Data.Array.Parallel.Base.DTrace
 import Data.Array.Parallel.Stream (
   Step(..), Stream(..),
@@ -228,7 +228,7 @@ combineU f a1 a2 = checkEq (here "combineU")
 --  trace ("combineU:\n\t"  ++ show (lengthU f)  ++ "\n\t" ++ show (lengthU a1) ++ "\n\t" ++ show (lengthU a2) ++ "\n")
   unstreamU (combineS (streamU f) (streamU a1) (streamU a2))
 
-combine2ByTagU :: UA a => UArr Int -> UArr a -> UArr a -> UArr a
+combine2ByTagU :: UA a => UArr Tag -> UArr a -> UArr a -> UArr a
 {-# INLINE_U combine2ByTagU #-}
 combine2ByTagU ts xs ys
   = checkEq (here "combine2ByTagU")
index f7dda6f..a17cc41 100644 (file)
@@ -32,9 +32,9 @@ import Data.Array.Parallel.Unlifted.Sequential.Flat.UArr (
 import Data.Array.Parallel.Unlifted.Sequential.Flat.Stream (
   streamU, unstreamU )
 import Data.Array.Parallel.Stream ( mapAccumS )
-import Data.Array.Parallel.Base ((:*:)(..))
+import Data.Array.Parallel.Base (Tag, (:*:)(..))
 
-data USel2 = USel2 { usel2_tags      :: !(UArr Int)
+data USel2 = USel2 { usel2_tags      :: !(UArr Tag)
                    , usel2_indices   :: !(UArr Int)
                    , usel2_elements0 :: !Int
                    , usel2_elements1 :: !Int
@@ -44,7 +44,7 @@ lengthUSel2 :: USel2 -> Int
 {-# INLINE lengthUSel2 #-}
 lengthUSel2 = lengthU . usel2_tags
 
-tagsUSel2 :: USel2 -> UArr Int
+tagsUSel2 :: USel2 -> UArr Tag
 {-# INLINE tagsUSel2 #-}
 tagsUSel2 = usel2_tags
 
@@ -60,11 +60,11 @@ elementsUSel2_1 :: USel2 -> Int
 {-# INLINE elementsUSel2_1 #-}
 elementsUSel2_1 = usel2_elements1
 
-mkUSel2 :: UArr Int -> UArr Int -> Int -> Int -> USel2
+mkUSel2 :: UArr Tag -> UArr Int -> Int -> Int -> USel2
 {-# INLINE mkUSel2 #-}
 mkUSel2 = USel2
 
-tagsToIndices2 :: UArr Int -> UArr Int
+tagsToIndices2 :: UArr Tag -> UArr Int
 {-# INLINE tagsToIndices2 #-}
 tagsToIndices2 tags = unstreamU (mapAccumS add (0 :*: 0) (streamU tags))
   where