dph-lifted-vseg: cleanups and add missing instances
authorBen Lippmeier <benl@ouroborus.net>
Mon, 17 Oct 2011 05:42:27 +0000 (16:42 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Mon, 17 Oct 2011 05:42:27 +0000 (16:42 +1100)
dph-lifted-vseg/Data/Array/Parallel/PArray.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Int.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Tuple.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Unit.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Void.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PData/Wrap.hs
dph-lifted-vseg/Data/Array/Parallel/PArray/PRepr/Base.hs

index 3e374b0..de0854f 100644 (file)
@@ -1,4 +1,4 @@
-{-# GHC_OPTIONS -fno-spec-constr #-}
+{-# OPTIONS -fno-spec-constr #-}
 #include "fusion-phases.h"
 
 -- | Functions that work directly on PArrays.
@@ -21,8 +21,6 @@ module Data.Array.Parallel.PArray
         , nfPA
         , replicatePA
         , replicatesPA
---      , fromVectorPA
---        , toVectorPA
         , indexPA
        , indexlPA
         , extractPA
@@ -30,13 +28,13 @@ module Data.Array.Parallel.PArray
         , appendPA
         , packByTagPA
         , combine2PA
-       , fromUArrayPA
-       , toUArrayPA
-        
+        , fromVectorPA
+        , toVectorPA
+
         -- Derived operators.
         , singletonPA
---        , fromListPA
---        , toListPA
+        , fromListPA
+        , toListPA
        , fromUArray2PA
        , nestUSegdPA
         , concatPA
@@ -54,10 +52,10 @@ module Data.Array.Parallel.PArray
 
         -- Wrappers used for testing only.
         , replicatesPA'
--       , extractsPA'
+        , extractsPA'
         , packByTagPA'
-        , combine2PA')
---        , slicelPA')
+        , combine2PA'
+        , slicelPA')
 where
 import Data.Array.Parallel.PArray.PData
 import Data.Array.Parallel.PArray.PRepr
@@ -68,11 +66,11 @@ import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
 import GHC.Exts
 
-{-
+
 instance (Eq a, PA a)  => Eq (PArray a) where
- (==) (PArray _ xs) (PArray _ ys) = toVectorPA xs == toVectorPA ys
- (/=) (PArray _ xs) (PArray _ ys) = toVectorPA xs /= toVectorPA ys
--}
+ (==) (PArray _ xs) (PArray _ ys) = toVectorPD xs == toVectorPD ys
+ (/=) (PArray _ xs) (PArray _ ys) = toVectorPD xs /= toVectorPD ys
+
 
 -- | Check that an array has a valid internal representation.
 {-# INLINE_PA validPA #-}
@@ -115,7 +113,7 @@ replicatesPA repCounts (PArray _ darr)
    in   PArray  n#
                 (replicatesPD (U.lengthsToSegd repCounts) darr)
 
-{-
+
 -- | Convert a `Vector` to a `PArray`
 {-# INLINE_PA fromVectorPA #-}
 fromVectorPA :: PA a => Vector a -> PArray a
@@ -129,7 +127,7 @@ fromVectorPA vec
 toVectorPA   :: PA a => PArray a -> Vector a
 toVectorPA (PArray _ arr)
         = toVectorPD arr
--}
+
 
 -- | Lookup a single element from the source array.
 {-# INLINE_PA indexPA #-}
@@ -199,7 +197,7 @@ singletonPA :: PA a => a -> PArray a
 singletonPA x
         = PArray 1# (replicatePD 1 x)
 
-{-
+
 -- | Convert a list to a `PArray`.
 {-# INLINE_PA fromListPA #-}
 fromListPA :: PA a => [a] -> PArray a
@@ -213,7 +211,7 @@ fromListPA xx
 toListPA   :: PA a => PArray a -> [a]
 toListPA (PArray _ arr)
         = V.toList $ toVectorPD arr
--}
+
 
 -- | Convert an unlifted array of pairs to a PArray of pairs.
 {-# INLINE_PA fromUArray2PA #-}
@@ -298,14 +296,14 @@ replicatesPA' lens arr
 
 
 -- | Segmented extract.
-{-extractsPA' :: PA a => V.Vector (PArray a) -> [Int] ->  [Int] -> [Int] -> PArray a
+extractsPA' :: PA a => V.Vector (PArray a) -> [Int] ->  [Int] -> [Int] -> PArray a
 extractsPA' arrs srcids startixs seglens
-        = PArray (sum seglens) 
-        $ extractsPR
+ = let  !(I# n#) = sum seglens
+   in   PArray n#
+        $ extractsPD
                 (V.map unpackPA arrs) 
-                (U.
-                     (U.fromList srcids) (U.fromList startixs) (U.fromList seglens)
--}
+                (U.mkSSegd (U.fromList srcids) (U.fromList startixs)
+                        $ U.lengthsToSegd (U.fromList seglens))
 
 -- | Filter an array based on some tags.
 packByTagPA' :: PA a => PArray a -> [Int] -> Int -> PArray a
@@ -320,9 +318,10 @@ combine2PA' sel (PArray _ darr1) (PArray _ darr2)
  = let  darr'   = combine2PD (U.tagsToSel2 (U.fromList sel)) darr1 darr2
    in   PArray 0# darr'
 
-{-
+
 -- | Extract some slices from some arrays.
 slicelPA' :: PA a => [Int] -> [Int] -> PArray (PArray a) -> PArray (PArray a)
 slicelPA' sliceStarts sliceLens arr
         = slicelPA (fromListPA sliceStarts) (fromListPA sliceLens) arr
--}
\ No newline at end of file
+
+
index 39ab792..e05b94a 100644 (file)
@@ -1,11 +1,3 @@
-{-# LANGUAGE
-        CPP,
-        TypeFamilies,
-        FlexibleInstances, FlexibleContexts,
-        MultiParamTypeClasses,
-        StandaloneDeriving,
-        ExistentialQuantification #-}
-
 #include "fusion-phases.h"
 
 module Data.Array.Parallel.PArray.PData.Int where
@@ -15,6 +7,8 @@ import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
 import Text.PrettyPrint
 
+
+-- Show -----------------------------------------------------------------------
 deriving instance Show (PData Int)
 
 
@@ -29,6 +23,7 @@ instance PprVirtual (PData Int) where
    = text (show $ U.toList vec)
 
 
+-- PR -------------------------------------------------------------------------
 instance PR Int where
   {-# INLINE_PDATA validPR #-}
   validPR _
index 6f7fcd0..437bac6 100644 (file)
@@ -9,10 +9,13 @@ import qualified Data.Vector                    as V
 import Text.PrettyPrint
 import GHC.Exts
 
+
+-------------------------------------------------------------------------------
 data instance PData (a, b)
         = PTuple2 (PData a) (PData b)
 
 
+-- Show -----------------------------------------------------------------------
 deriving instance (Show (PData a), Show (PData b)) 
         => Show (PData (a, b))
 
@@ -32,6 +35,7 @@ instance ( PR a, PR b, Show a, Show b
               (V.toList $ toVectorPR ys)
 
 
+-- PR -------------------------------------------------------------------------
 instance (PR a, PR b) => PR (a, b) where
   {-# INLINE_PDATA validPR #-}
   validPR (PTuple2 xs ys)
@@ -115,6 +119,7 @@ instance (PR a, PR b) => PR (a, b) where
                  (toVectorPR ys)
 
 
+-- Derived --------------------------------------------------------------------
 -- | Zip a pair of arrays into an array of pairs.
 --   The two arrays must have the same length, else `error`. 
 {-# INLINE_PA zipPA #-}
@@ -139,7 +144,8 @@ unzipPA (PArray n# (PTuple2 xs ys))
 unziplPR  :: (PR a, PR b)
           => PData (PArray (a, b)) -> PData (PArray a, PArray b)
 unziplPR (PNested uvsegd psegdata)
- = let  (xsdata, ysdata)        = V.unzip $ V.map (\(PTuple2 xs ys) -> (xs, ys)) psegdata
+ = let  (xsdata, ysdata)        
+         = V.unzip $ V.map (\(PTuple2 xs ys) -> (xs, ys)) psegdata
    in   PTuple2 (PNested uvsegd xsdata)
                 (PNested uvsegd ysdata)
 
index da04a34..0b095a1 100644 (file)
@@ -7,6 +7,7 @@ import qualified Data.Vector                    as V
 import Text.PrettyPrint
 
 
+-------------------------------------------------------------------------------
 -- | NOTE: We're only maintaining the length temporarilly. 
 --         This is done so that the validPA checks work, but in future we'll 
 --         fix validPA so it handles 'defined everywhere' arrays.
@@ -16,6 +17,8 @@ data instance PData ()
 punit :: PData ()
 punit =  PUnit 0
 
+
+-- Show -----------------------------------------------------------------------
 deriving instance Show (PData ())
 
 instance PprPhysical (PData ()) where
@@ -27,6 +30,7 @@ instance PprVirtual (PData ()) where
    = text $ "[ () x " ++ show n ++ " ]"
 
 
+-- PR -------------------------------------------------------------------------
 instance PR () where
   {-# INLINE_PDATA validPR #-}
   validPR _
index 99e3912..c50da27 100644 (file)
@@ -1,9 +1,14 @@
+#include "fusion-phases.h"
 
-module Data.Array.Parallel.PArray.PData.Void where
+module Data.Array.Parallel.PArray.PData.Void 
+        (Void, pvoid)
+where
 import Data.Array.Parallel.PArray.PData.Base
 import Data.Array.Parallel.PArray.Types
 import Data.Array.Parallel.PArray.PRepr.Base
 
+
+-------------------------------------------------------------------------------
 -- | The Void type is used when representing enumerations. 
 --   A type like Bool is represented as @Sum2 Void Void@, meaning that we only
 --   only care about the tag of the data constructor and not its argumnent.
@@ -11,7 +16,57 @@ import Data.Array.Parallel.PArray.PRepr.Base
 data instance PData Void
 
 pvoid :: PData Void
-pvoid =  error "Data.Array.Parallel.PData Void"
+pvoid   = error "Data.Array.Parallel.PData.Void"
+
+
+-- PR --------------------------------------------------------------------------
+nope    = error "Data.Array.Parallel.PData.Void: no PR method for void"
 
 instance PR Void where
-        
\ No newline at end of file
+  {-# INLINE_PDATA validPR #-}
+  validPR       = nope
+
+  {-# INLINE_PDATA emptyPR #-}
+  emptyPR       = nope
+
+  {-# INLINE_PDATA nfPR #-}
+  nfPR          = nope
+
+  {-# INLINE_PDATA lengthPR #-}
+  lengthPR      = nope
+
+  {-# INLINE_PDATA replicatePR #-}
+  replicatePR   = nope
+
+  {-# INLINE_PDATA replicatesPR #-}
+  replicatesPR  = nope
+                
+  {-# INLINE_PDATA indexPR #-}
+  indexPR       = nope
+
+  {-# INLINE_PDATA indexlPR #-}
+  indexlPR      = nope
+
+  {-# INLINE_PDATA extractPR #-}
+  extractPR     = nope
+
+  {-# INLINE_PDATA extractsPR #-}
+  extractsPR    = nope
+
+  {-# INLINE_PDATA appendPR #-}
+  appendPR      = nope
+  
+  {-# INLINE_PDATA appendsPR #-}
+  appendsPR     = nope
+
+  {-# INLINE_PDATA packByTagPR #-}
+  packByTagPR   = nope
+
+  {-# INLINE_PDATA combine2PR #-}
+  combine2PR    = nope
+
+  {-# INLINE_PDATA fromVectorPR #-}
+  fromVectorPR  = nope
+
+  {-# INLINE_PDATA toVectorPR #-}
+  toVectorPR    = nope
\ No newline at end of file
index fd365c9..b607d56 100644 (file)
@@ -1,17 +1,15 @@
 
 module Data.Array.Parallel.PArray.PData.Wrap where
 import Data.Array.Parallel.PArray.PData.Base
+import Data.Array.Parallel.PArray.PData.Nested
 import Data.Array.Parallel.PArray.Types
 import Data.Array.Parallel.PArray.PRepr.Base
 import Data.Vector.Unboxed                      (Vector)
+import qualified Data.Vector                    as V
 
 newtype instance PData (Wrap a)
         = PWrap (PData a)
 
-newtype instance Vector (Wrap a)
-        = VWrap (Vector a)
-        
-
 instance PA a => PR (Wrap a) where       
 
   validPR (PWrap pdata)  
@@ -35,14 +33,17 @@ instance PA a => PR (Wrap a) where
   indexPR (PWrap xs) ix
         = Wrap  $ indexPD xs ix
 
---  indexlPR n (PNested ) ixs                   -- hmm
---        = PWrap (indexlPD n xs ixs)
+  -- PROBLEM: unwrapping isn't O(1).
+  indexlPR n (PNested vsegd pdatas) ixs
+   = let pdatas' = V.map (\(PWrap a) -> a) pdatas
+     in  PWrap (indexlPD n (PNested vsegd pdatas') ixs)
 
   extractPR (PWrap xs) ix n
         = PWrap $ extractPD xs ix n
         
+  -- PROBLEM: unwrapping isn't O(1).
   extractsPR vecs ssegd
-        = PWrap $ extractsPD (V.map (\(PWrap xs) -> xs) vecs) ssegd
+        = PWrap $ extractsPD (V.map (\(PWrap a) -> a) vecs) ssegd
 
   appendPR (PWrap xs) (PWrap ys)
         = PWrap $ appendPD xs ys
@@ -54,4 +55,10 @@ instance PA a => PR (Wrap a) where
         = PWrap $ packByTagPD xs tags tag
 
   combine2PR sel (PWrap xs) (PWrap ys)
-        = PWrap $ combine2PD sel xs ys
\ No newline at end of file
+        = PWrap $ combine2PD sel xs ys
+
+  fromVectorPR vec 
+        = PWrap $ fromVectorPD $ V.map unWrap vec
+        
+  toVectorPR (PWrap pdata)
+        = V.map Wrap $ toVectorPD pdata
index e03e563..94dfb4f 100644 (file)
@@ -21,7 +21,8 @@ module Data.Array.Parallel.PArray.PRepr.Base (
         extractPD,      extractsPD,
         appendPD,       appendsPD,
         packByTagPD,
-        combine2PD
+        combine2PD,
+        fromVectorPD,   toVectorPD
 )
 where
 import Data.Array.Parallel.PArray.PData.Base
@@ -30,7 +31,6 @@ import Data.Array.Parallel.Base                 (Tag)
 import qualified Data.Array.Parallel.Unlifted   as U
 import qualified Data.Vector                    as V
 
-nope    = error "Data.Array.Parallel.PArray.PRepr.Base: nope"
 
 -- | Representable types.
 --
@@ -59,7 +59,7 @@ class PR (PRepr a) => PA a where
   -- PROBLEM: 
   --  The new library needs these conversion functions, but the default
   --  conversion isn't O(1). Perhaps we should be using an (Int -> PData a)
-  --  functioninstead of a vector, then conversion would just be 
+  --  function instead of a vector, then conversion would just be 
   --  function composition.
   toArrPReprs           :: Vector (PData a)         -> Vector (PData (PRepr a))
   toArrPReprs arrs
@@ -180,3 +180,19 @@ combine2PD      :: PA a => U.Sel2 -> PData a -> PData a -> PData a
 combine2PD sel xs ys
  = fromArrPRepr
  $ combine2PR sel (toArrPRepr xs) (toArrPRepr ys)
+{-# INLINE_PA fromVectorPD #-}
+fromVectorPD    :: PA a => Vector a -> PData a
+fromVectorPD vec
+ = fromArrPRepr
+ $ fromVectorPR (V.map toPRepr vec)
+
+
+{-# INLINE_PA toVectorPD #-}
+toVectorPD      :: PA a => PData a -> Vector a
+toVectorPD pdata
+ = V.map fromPRepr
+ $ toVectorPR (toArrPRepr pdata)
+
\ No newline at end of file