Remove packPR and friends
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 12 Nov 2009 07:08:25 +0000 (07:08 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Thu, 12 Nov 2009 07:08:25 +0000 (07:08 +0000)
We use packByTagPR instead

dph-common/Data/Array/Parallel/Lifted/Closure.hs
dph-common/Data/Array/Parallel/Lifted/PArray.hs
dph-common/Data/Array/Parallel/Lifted/Repr.hs
dph-common/Data/Array/Parallel/Lifted/TH/Repr.hs

index 714fbf3..dfe960c 100644 (file)
@@ -117,9 +117,6 @@ instance PR (a :-> b) where
   {-# INLINE bpermutePR #-}
   bpermutePR (AClo f f' es) n# is = AClo f f' (bpermutePD es n# is)
 
-  {-# INLINE packPR #-}
-  packPR (AClo f f' es) n# sel = AClo f f' (packPD es n# sel)
-
   {-# INLINE packByTagPR #-}
   packByTagPR (AClo f f' es) n# tags t# = AClo f f' (packByTagPD es n# tags t#)
 
index 5386aff..7c29107 100644 (file)
@@ -8,18 +8,18 @@ module Data.Array.Parallel.Lifted.PArray (
   PA(..),
   lengthPA#, dataPA#, replicatePA#, replicatelPA#, repeatPA#, repeatcPA#,
   emptyPA, indexPA#, extractPA#, bpermutePA#, appPA#, applPA#,
-  packPA#, packByTagPA#, combine2PA#, fromListPA#, fromListPA, nfPA,
+  packByTagPA#, combine2PA#, fromListPA#, fromListPA, nfPA,
 
   replicatePD, replicatelPD, repeatPD, repeatcPD, emptyPD,
   indexPD, extractPD, bpermutePD, appPD, applPD,
-  packPD, packByTagPD, combine2PD, fromListPD, fromListPD, nfPD,
+  packByTagPD, combine2PD, fromListPD, fromListPD, nfPD,
 
   PRepr, PR(..),
 
   Scalar(..),
   replicatePRScalar, replicatelPRScalar, repeatPRScalar, repeatcPRScalar, emptyPRScalar,
   indexPRScalar, extractPRScalar, bpermutePRScalar, appPRScalar, applPRScalar,
-  packPRScalar, packByTagPRScalar, combine2PRScalar, fromListPRScalar, fromListPRScalar,
+  packByTagPRScalar, combine2PRScalar, fromListPRScalar, fromListPRScalar,
   nfPRScalar,
 ) where
 
@@ -84,11 +84,6 @@ type T_applPR       a =  U.Segd -> PData a   -- src segd/data 1
                       -> U.Segd -> PData a   -- src segd/data 2
                       -> PData a
 
-type T_packPR       a =  PData a
-                      -> Int#              -- result length
-                      -> U.Array Bool      -- flags
-                      -> PData a
-
 type T_packByTagPR  a = PData a
                       -> Int#              -- result length
                       -> U.Array Int       -- tags
@@ -114,7 +109,6 @@ class PR a where
   bpermutePR   :: T_bpermutePR a
   appPR        :: T_appPR a
   applPR       :: T_applPR a
-  packPR       :: T_packPR a
   packByTagPR  :: T_packByTagPR a
   combine2PR   :: T_combine2PR a
   fromListPR   :: T_fromListPR a
@@ -168,10 +162,6 @@ applPD :: PA a => T_applPR a
 {-# INLINE_PA applPD #-}
 applPD is xs js ys = fromArrPRepr $ applPR is (toArrPRepr xs) js (toArrPRepr ys)
 
-packPD :: PA a => T_packPR a
-{-# INLINE_PA packPD #-}
-packPD xs n# bs = fromArrPRepr $ packPR (toArrPRepr xs) n# bs
-
 packByTagPD :: PA a => T_packByTagPR a
 {-# INLINE_PA packByTagPD #-}
 packByTagPD xs n# tags t#
@@ -243,10 +233,6 @@ applPA# :: PA a => U.Segd -> PArray a -> U.Segd -> PArray a -> PArray a
 applPA# is (PArray m# xs) js (PArray n# ys)
   = PArray (m# +# n#) (applPD is xs js ys)
 
-packPA# :: PA a => PArray a -> Int# -> U.Array Bool -> PArray a
-{-# INLINE_PA packPA# #-}
-packPA# (PArray _ xs) n# bs = PArray n# (packPD xs n# bs)
-
 packByTagPA# :: PA a => PArray a -> Int# -> U.Array Int -> Int# -> PArray a
 {-# INLINE_PA packByTagPA# #-}
 packByTagPA# (PArray _ xs) n# tags t# = PArray n# (packByTagPD xs n# tags t#)
@@ -325,11 +311,6 @@ applPRScalar xsegd xs ysegd ys = toScalarPData
                              $ U.append_s xsegd (fromScalarPData xs)
                                           ysegd (fromScalarPData ys)
                         
-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
index 881403e..84bbe4b 100644 (file)
@@ -143,11 +143,6 @@ instance (PR a, PR b) => PR (a,b) where
       P_2 (applPR is as1 js as2)
           (applPR is bs1 js bs2)
 
-  {-# INLINE packPR #-}
-  packPR (P_2 as bs) n# sel# =
-      P_2 (packPR as n# sel#)
-          (packPR bs n# sel#)
-
   {-# INLINE packByTagPR #-}
   packByTagPR (P_2 as bs) n# tags t# =
       P_2 (packByTagPR as n# tags t#)
@@ -258,21 +253,6 @@ instance (PR a, PR b) => PR (Sum2 a b) where
       sel = tagsToSel2
           $ tagsSel2 sel1 U.+:+ tagsSel2 sel2
 
-  {-# INLINE packPR #-}
-  packPR (PSum2 sel as bs) m# flags
-    = traceFn "packPR" "(Sum2 a b)" $
-      PSum2 sel' as' bs'
-    where
-      tags   = tagsSel2 sel
-      tags'  = U.pack tags flags
-      sel'   = tagsToSel2 tags'
-
-      aFlags = U.pack flags (U.pick tags 0)
-      bFlags = U.pack flags (U.pick tags 1)
-
-      as'    = packPR as (elementsSel2_0# sel') aFlags
-      bs'    = packPR bs (elementsSel2_1# sel') bFlags
-
   {-# INLINE packByTagPR #-}
   packByTagPR (PSum2 sel as bs) n# tags t#
     = PSum2 sel' as' bs'
@@ -385,16 +365,6 @@ instance PR a => PR (PArray a) where
                             (U.lengthsSegd segd)
                             xsegd xs
 
-  {-# INLINE packPR #-}
-  packPR (PNested segd xs) n# flags
-    = traceFn "packPR" "(PArray a)" $
-    PNested segd' xs'
-    where
-      segd' = U.lengthsToSegd
-            $ U.pack (U.lengthsSegd segd) flags
-
-      xs'   = packPR xs (elementsSegd# segd') (U.replicate_s segd flags)
-
   {-# INLINE packByTagPR #-}
   packByTagPR (PNested segd xs) n# tags t#
     = PNested segd' xs'
index 1ccf735..fce4694 100644 (file)
@@ -180,7 +180,6 @@ nameGens =
   , ('bpermutePR,       [id, const "n#", const "is"])
   , ('appPR,            [(++"1"), (++"2")])
   , ('applPR,           [const "is", (++"1"), const "js", (++"2")])
-  , ('packPR,           [id, const "n#", const "sel"])
   , ('packByTagPR,      [id, const "n#", const "tags", const "t#"])
   , ('combine2PR,       [const "n#", const "sel", (++"1"), (++"2")])
   , ('fromListPR,       [const "n#", id])